fugue 0.8.7.dev5__py3-none-any.whl → 0.8.7.dev7__py3-none-any.whl

fugue_dask/_io.py

@@ -1,13 +1,12 @@
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
-import fsspec
-import fs as pfs
 import pandas as pd
 from dask import dataframe as dd
+from fsspec import AbstractFileSystem
 from triad.collections.dict import ParamDict
-from triad.collections.fs import FileSystem
 from triad.collections.schema import Schema
 from triad.utils.assertion import assert_or_throw
+from triad.utils.io import join, makedirs, url_to_fs
 
 from fugue._utils.io import FileParser, _get_single_files
 from fugue_dask.dataframe import DaskDataFrame
@@ -19,7 +18,7 @@ def load_df(
     uri: Union[str, List[str]],
     format_hint: Optional[str] = None,
     columns: Any = None,
-    fs: Optional[FileSystem] = None,
+    fs: Optional[AbstractFileSystem] = None,
     **kwargs: Any,
 ) -> DaskDataFrame:
     if isinstance(uri, str):
@@ -39,7 +38,7 @@ def save_df(
     uri: str,
     format_hint: Optional[str] = None,
     mode: str = "overwrite",
-    fs: Optional[FileSystem] = None,
+    fs: Optional[AbstractFileSystem] = None,
     **kwargs: Any,
 ) -> None:
     assert_or_throw(
@@ -48,16 +47,13 @@ def save_df(
     )
     p = FileParser(uri, format_hint).assert_no_glob()
     if fs is None:
-        fs = FileSystem()
+        fs, _ = url_to_fs(uri)
     if fs.exists(uri):
         assert_or_throw(mode == "overwrite", FileExistsError(uri))
         try:
-            fs.remove(uri)
-        except Exception:
-            try:
-                fs.removetree(uri)
-            except Exception:  # pragma: no cover
-                pass
+            fs.rm(uri, recursive=True)
+        except Exception:  # pragma: no cover
+            pass
     _FORMAT_SAVE[p.file_format](df, p, **kwargs)
 
 
@@ -67,7 +63,7 @@ def _save_parquet(df: DaskDataFrame, p: FileParser, **kwargs: Any) -> None:
         "write_index": False,
         **kwargs,
     }
-    DASK_UTILS.to_parquet_friendly(df.native).to_parquet(p.uri, **params)
+    DASK_UTILS.to_parquet_friendly(df.native).to_parquet(p.path, **params)
 
 
 def _load_parquet(
@@ -80,27 +76,26 @@ def _load_parquet(
     if pd.__version__ >= "1.5":
         dtype_backend = "pyarrow"
     if columns is None:
-        pdf = dd.read_parquet(p.uri, dtype_backend=dtype_backend, **params)
+        pdf = dd.read_parquet(p.path, dtype_backend=dtype_backend, **params)
         schema = Schema(pdf.head(1))
         return pdf, schema
     if isinstance(columns, list):  # column names
         pdf = dd.read_parquet(
-            p.uri, columns=columns, dtype_backend=dtype_backend, **params
+            p.path, columns=columns, dtype_backend=dtype_backend, **params
         )
         schema = Schema(pdf.head(1))
         return pdf, schema
     schema = Schema(columns)
     pdf = dd.read_parquet(
-        p.uri, columns=schema.names, dtype_backend=dtype_backend, **params
+        p.path, columns=schema.names, dtype_backend=dtype_backend, **params
     )
     return pdf, schema
 
 
 def _save_csv(df: DaskDataFrame, p: FileParser, **kwargs: Any) -> None:
-    fs, path = fsspec.core.url_to_fs(p.uri)
-    fs.makedirs(path, exist_ok=True)
+    makedirs(p.path, exist_ok=True)
     df.native.to_csv(
-        pfs.path.combine(p.uri, "*.csv"), **{"index": False, "header": False, **kwargs}
+        p.join("*.csv").path, **{"index": False, "header": False, **kwargs}
     )
 
 
@@ -108,7 +103,7 @@ def _safe_load_csv(path: str, **kwargs: Any) -> dd.DataFrame:
     try:
         return dd.read_csv(path, **kwargs)
     except (IsADirectoryError, PermissionError):
-        return dd.read_csv(pfs.path.combine(path, "*.csv"), **kwargs)
+        return dd.read_csv(join(path, "*.csv"), **kwargs)
 
 
 def _load_csv(  # noqa: C901
@@ -127,7 +122,7 @@ def _load_csv(  # noqa: C901
         header = kw["header"]
         del kw["header"]
     if str(header) in ["True", "0"]:
-        pdf = _safe_load_csv(p.uri, **{"header": 0, **kw})
+        pdf = _safe_load_csv(p.path, **{"header": 0, **kw})
         if columns is None:
             return pdf, None
         if isinstance(columns, list):  # column names
@@ -138,34 +133,32 @@ def _load_csv(  # noqa: C901
         if columns is None:
             raise ValueError("columns must be set if without header")
         if isinstance(columns, list):  # column names
-            pdf = _safe_load_csv(p.uri, **{"header": None, "names": columns, **kw})
+            pdf = _safe_load_csv(p.path, **{"header": None, "names": columns, **kw})
             return pdf, None
         schema = Schema(columns)
-        pdf = _safe_load_csv(p.uri, **{"header": None, "names": schema.names, **kw})
+        pdf = _safe_load_csv(p.path, **{"header": None, "names": schema.names, **kw})
         return pdf, schema
     else:
         raise NotImplementedError(f"{header} is not supported")
 
 
 def _save_json(df: DaskDataFrame, p: FileParser, **kwargs: Any) -> None:
-    fs, path = fsspec.core.url_to_fs(p.uri)
-    fs.makedirs(path, exist_ok=True)
-    df.native.to_json(pfs.path.combine(p.uri, "*.json"), **kwargs)
+    makedirs(p.path, exist_ok=True)
+    df.native.to_json(p.join("*.json").path, **kwargs)
 
 
 def _safe_load_json(path: str, **kwargs: Any) -> dd.DataFrame:
     try:
         return dd.read_json(path, **kwargs)
     except (IsADirectoryError, PermissionError):
-        x = dd.read_json(pfs.path.combine(path, "*.json"), **kwargs)
-        print(x.compute())
+        x = dd.read_json(join(path, "*.json"), **kwargs)
         return x
 
 
 def _load_json(
     p: FileParser, columns: Any = None, **kwargs: Any
 ) -> Tuple[dd.DataFrame, Any]:
-    pdf = _safe_load_json(p.uri, **kwargs).reset_index(drop=True)
+    pdf = _safe_load_json(p.path, **kwargs).reset_index(drop=True)
     if columns is None:
         return pdf, None
     if isinstance(columns, list):  # column names

fugue_dask/_utils.py

@@ -1,13 +1,14 @@
 import math
-from typing import Any, List, Optional, Tuple
+from typing import Any, Callable, List, Optional, Tuple, TypeVar
 
 import dask.dataframe as dd
 import numpy as np
 import pandas as pd
 import pyarrow as pa
 from dask.dataframe.core import DataFrame
+from dask.delayed import delayed
 from dask.distributed import Client, get_client
-from triad.utils.pandas_like import PandasLikeUtils, PD_UTILS
+from triad.utils.pandas_like import PD_UTILS, PandasLikeUtils
 from triad.utils.pyarrow import to_pandas_dtype
 
 import fugue.api as fa
@@ -16,6 +17,7 @@ from fugue.constants import FUGUE_CONF_DEFAULT_PARTITIONS
 from ._constants import FUGUE_DASK_CONF_DEFAULT_PARTITIONS
 
 _FUGUE_DASK_TEMP_IDX_COLUMN = "_fugue_dask_temp_index"
+T = TypeVar("T")
 
 
 def get_default_partitions() -> int:
@@ -28,6 +30,17 @@ def get_default_partitions() -> int:
     return n if n > 0 else fa.get_current_parallelism() * 2
 
 
+def collect(df: dd.DataFrame, func: Callable[[pd.DataFrame], T]) -> Tuple[T]:
+    """Compute each partition in parallel and collect the results
+
+    :param df: dask dataframe
+    :return: the collected result
+    """
+    dfs = df.to_delayed()
+    objs = [delayed(func)(df) for df in dfs]
+    return dd.compute(*objs)
+
+
 def hash_repartition(df: dd.DataFrame, num: int, cols: List[Any]) -> dd.DataFrame:
     """Repartition the dataframe by hashing the given columns
 

fugue_dask/dataframe.py

@@ -3,20 +3,21 @@ from typing import Any, Dict, Iterable, List, Optional, Tuple
 import dask.dataframe as dd
 import pandas as pd
 import pyarrow as pa
+from triad import assert_or_throw
 from triad.collections.schema import Schema
 from triad.utils.assertion import assert_arg_not_none
 from triad.utils.pandas_like import PD_UTILS
 from triad.utils.pyarrow import cast_pa_table
 
-from fugue.dataframe import (
-    ArrowDataFrame,
-    DataFrame,
-    LocalBoundedDataFrame,
-    PandasDataFrame,
-)
+from fugue.dataframe import DataFrame, LocalBoundedDataFrame, PandasDataFrame
 from fugue.dataframe.dataframe import _input_schema
+from fugue.dataframe.pandas_dataframe import _pd_as_dicts
 from fugue.exceptions import FugueDataFrameOperationError
 from fugue.plugins import (
+    as_array,
+    as_array_iterable,
+    as_dict_iterable,
+    as_dicts,
     as_local_bounded,
     count,
     drop_columns,
@@ -32,7 +33,7 @@ from fugue.plugins import (
 )
 
 from ._constants import FUGUE_DASK_USE_ARROW
-from ._utils import DASK_UTILS, get_default_partitions
+from ._utils import DASK_UTILS, collect, get_default_partitions
 
 
 class DaskDataFrame(DataFrame):
@@ -150,8 +151,16 @@ class DaskDataFrame(DataFrame):
         )
 
     def as_arrow(self, type_safe: bool = False) -> pa.Table:
-        adf = pa.Table.from_pandas(self.native.compute().reset_index(drop=True))
-        return cast_pa_table(adf, self.schema.pa_schema)
+        schema = self.schema.pa_schema
+        return pa.concat_tables(
+            collect(
+                self.native,
+                lambda df: cast_pa_table(
+                    pa.Table.from_pandas(df.reset_index(drop=True), schema=schema),
+                    schema=schema,
+                ),
+            )
+        )
 
     def rename(self, columns: Dict[str, str]) -> DataFrame:
         try:
@@ -170,17 +179,28 @@ class DaskDataFrame(DataFrame):
     def as_array(
         self, columns: Optional[List[str]] = None, type_safe: bool = False
     ) -> List[Any]:
-        df: DataFrame = self
-        if columns is not None:
-            df = df[columns]
-        return ArrowDataFrame(df.as_pandas(), schema=df.schema).as_array(
-            type_safe=type_safe
-        )
+        chunks = _to_array_chunks(self.native, columns, type_safe, schema=self.schema)
+        res: List[List[Any]] = []
+        for x in chunks:
+            res += x
+        return res
 
     def as_array_iterable(
         self, columns: Optional[List[str]] = None, type_safe: bool = False
     ) -> Iterable[Any]:
-        yield from self.as_array(columns=columns, type_safe=type_safe)
+        chunks = _to_array_chunks(self.native, columns, type_safe, schema=self.schema)
+        for x in chunks:
+            yield from x
+
+    def as_dicts(
+        self, columns: Optional[List[str]] = None, type_safe: bool = False
+    ) -> List[Dict[str, Any]]:
+        return _dd_as_dicts(self.native, columns)
+
+    def as_dict_iterable(
+        self, columns: Optional[List[str]] = None, type_safe: bool = False
+    ) -> Iterable[Dict[str, Any]]:
+        yield from _dd_as_dict_iterable(self.native, columns)
 
     def head(
         self, n: int, columns: Optional[List[str]] = None
@@ -197,8 +217,11 @@ class DaskDataFrame(DataFrame):
             assert_arg_not_none(schema, "schema")
             return pdf, schema
         DASK_UTILS.ensure_compatible(pdf)
-        pschema = Schema(DASK_UTILS.to_schema(pdf))
-        if schema is None or pschema == schema:
+        # when pdf contains bytes, or any object types, and schema contains str
+        # there is no way to get the real schema of the pdf, (pschema will contain
+        # strs instead of the real types) so we have to force cast it to the schema
+        if schema is None:
+            pschema = Schema(DASK_UTILS.to_schema(pdf))
             return pdf, pschema.assert_not_empty()
         pdf = pdf[schema.assert_not_empty().names]
         return (
@@ -295,6 +318,48 @@ def _dd_head(
     return PandasDataFrame(res) if as_fugue else res
 
 
+@as_array.candidate(lambda df, *args, **kwargs: isinstance(df, dd.DataFrame))
+def _dd_as_array(
+    df: dd.DataFrame, columns: Optional[List[str]] = None, type_safe: bool = False
+) -> List[Any]:
+    chunks = _to_array_chunks(df, columns, type_safe)
+    res: List[List[Any]] = []
+    for x in chunks:
+        res += x
+    return res
+
+
+@as_array_iterable.candidate(lambda df, *args, **kwargs: isinstance(df, dd.DataFrame))
+def _dd_as_array_iterable(
+    df: dd.DataFrame, columns: Optional[List[str]] = None, type_safe: bool = False
+) -> Iterable[Any]:
+    chunks = _to_array_chunks(df, columns, type_safe)
+    for x in chunks:
+        yield from x
+
+
+@as_dicts.candidate(lambda df, *args, **kwargs: isinstance(df, dd.DataFrame))
+def _dd_as_dicts(
+    df: dd.DataFrame, columns: Optional[List[str]] = None, type_safe: bool = False
+) -> List[Dict[str, Any]]:
+    assert_or_throw(columns is None or len(columns) > 0, ValueError("empty columns"))
+    _df = df if columns is None or len(columns) == 0 else df[columns]
+    res: List[Dict[str, Any]] = []
+    for x in collect(_df, lambda df: _pd_as_dicts(df, columns)):
+        res += x
+    return res
+
+
+@as_dict_iterable.candidate(lambda df, *args, **kwargs: isinstance(df, dd.DataFrame))
+def _dd_as_dict_iterable(
+    df: dd.DataFrame, columns: Optional[List[str]] = None, type_safe: bool = False
+) -> Iterable[Dict[str, Any]]:
+    assert_or_throw(columns is None or len(columns) > 0, ValueError("empty columns"))
+    _df = df if columns is None or len(columns) == 0 else df[columns]
+    for x in collect(_df, lambda df: _pd_as_dicts(df, columns)):
+        yield from x
+
+
 def _assert_no_missing(df: dd.DataFrame, columns: Iterable[Any]) -> None:
     missing = set(columns) - set(df.columns)
     if len(missing) > 0:
@@ -303,3 +368,25 @@ def _assert_no_missing(df: dd.DataFrame, columns: Iterable[Any]) -> None:
 
 def _adjust_df(res: dd.DataFrame, as_fugue: bool):
     return res if not as_fugue else DaskDataFrame(res)
+
+
+def _to_array_chunks(
+    df: dd.DataFrame,
+    columns: Optional[List[str]] = None,
+    type_safe: bool = False,
+    schema: Optional[Schema] = None,
+) -> Tuple[List[Any]]:
+    assert_or_throw(columns is None or len(columns) > 0, ValueError("empty columns"))
+    _df = df if columns is None or len(columns) == 0 else df[columns]
+
+    def _to_list(pdf: pd.DataFrame) -> List[Any]:
+        return list(
+            PD_UTILS.as_array_iterable(
+                pdf,
+                schema=None if schema is None else schema.pa_schema,
+                columns=columns,
+                type_safe=type_safe,
+            )
+        )
+
+    return collect(_df, _to_list)

fugue_dask/execution_engine.py

@@ -7,18 +7,17 @@ import pandas as pd
 from distributed import Client
 from triad.collections import Schema
 from triad.collections.dict import IndexedOrderedDict, ParamDict
-from triad.collections.fs import FileSystem
 from triad.utils.assertion import assert_or_throw
 from triad.utils.hash import to_uuid
 from triad.utils.pandas_like import PandasUtils
 from triad.utils.threading import RunOnce
+from triad.utils.io import makedirs
 from fugue import StructuredRawSQL
 from fugue.collections.partition import (
     PartitionCursor,
     PartitionSpec,
     parse_presort_exp,
 )
-from fugue.exceptions import FugueBug
 from fugue.constants import KEYWORD_PARALLELISM, KEYWORD_ROWCOUNT
 from fugue.dataframe import (
     AnyDataFrame,
@@ -28,6 +27,7 @@ from fugue.dataframe import (
     PandasDataFrame,
 )
 from fugue.dataframe.utils import get_join_schemas
+from fugue.exceptions import FugueBug
 from fugue.execution.execution_engine import ExecutionEngine, MapEngine, SQLEngine
 from fugue.execution.native_execution_engine import NativeExecutionEngine
 from fugue_dask._constants import FUGUE_DASK_DEFAULT_CONF
@@ -206,7 +206,6 @@ class DaskExecutionEngine(ExecutionEngine):
         p = ParamDict(FUGUE_DASK_DEFAULT_CONF)
         p.update(ParamDict(conf))
         super().__init__(p)
-        self._fs = FileSystem()
         self._log = logging.getLogger()
         self._client = DASK_UTILS.get_or_create_client(dask_client)
         self._native = NativeExecutionEngine(conf=conf)
@@ -227,10 +226,6 @@ class DaskExecutionEngine(ExecutionEngine):
     def log(self) -> logging.Logger:
         return self._log
 
-    @property
-    def fs(self) -> FileSystem:
-        return self._fs
-
     def create_default_sql_engine(self) -> SQLEngine:
         return DaskSQLEngine(self)
 
@@ -527,9 +522,7 @@ class DaskExecutionEngine(ExecutionEngine):
         **kwargs: Any,
     ) -> DaskDataFrame:
         return self.to_df(
-            load_df(
-                path, format_hint=format_hint, columns=columns, fs=self.fs, **kwargs
-            )
+            load_df(path, format_hint=format_hint, columns=columns, **kwargs)
         )
 
     def save_df(
@@ -556,9 +549,9 @@ class DaskExecutionEngine(ExecutionEngine):
         else:
             if not partition_spec.empty:
                 kwargs["partition_on"] = partition_spec.partition_by
-            self.fs.makedirs(os.path.dirname(path), recreate=True)
+            makedirs(os.path.dirname(path), exist_ok=True)
             df = self.to_df(df)
-            save_df(df, path, format_hint=format_hint, mode=mode, fs=self.fs, **kwargs)
+            save_df(df, path, format_hint=format_hint, mode=mode, **kwargs)
 
 
 def to_dask_engine_df(df: Any, schema: Any = None) -> DaskDataFrame:

fugue_duckdb/_io.py

@@ -3,9 +3,9 @@ from typing import Any, Iterable, List, Optional, Union
 
 from duckdb import DuckDBPyConnection
 from triad import ParamDict, Schema
-from triad.collections.fs import FileSystem
-from triad.utils.assertion import assert_or_throw
 
+from triad.utils.assertion import assert_or_throw
+from triad.utils.io import isdir, makedirs, rm, exists
 from fugue._utils.io import FileParser, load_df, save_df
 from fugue.collections.sql import TempTableName
 from fugue.dataframe import ArrowDataFrame, LocalBoundedDataFrame
@@ -18,26 +18,17 @@ from fugue_duckdb._utils import (
 from fugue_duckdb.dataframe import DuckDataFrame
 
 
-def _get_single_files(
-    fp: Iterable[FileParser], fs: FileSystem, fmt: str
-) -> Iterable[FileParser]:
-    def _isdir(d: str) -> bool:
-        try:
-            return fs.isdir(d)
-        except Exception:  # pragma: no cover
-            return False
-
+def _get_files(fp: Iterable[FileParser], fmt: str) -> Iterable[FileParser]:
     for f in fp:
-        if f.glob_pattern == "" and _isdir(f.uri):
-            yield f.with_glob("*." + fmt, fmt)
+        if not f.has_glob and isdir(f.path):
+            yield from f.join("*." + fmt, fmt).find_all()
         else:
             yield f
 
 
 class DuckDBIO:
-    def __init__(self, fs: FileSystem, con: DuckDBPyConnection) -> None:
+    def __init__(self, con: DuckDBPyConnection) -> None:
         self._con = con
-        self._fs = fs
         self._format_load = {"csv": self._load_csv, "parquet": self._load_parquet}
         self._format_save = {"csv": self._save_csv, "parquet": self._save_parquet}
 
@@ -55,11 +46,9 @@ class DuckDBIO:
         else:
             fp = [FileParser(u, format_hint) for u in uri]
         if fp[0].file_format not in self._format_load:
-            return load_df(
-                uri, format_hint=format_hint, columns=columns, fs=self._fs, **kwargs
-            )
+            return load_df(uri, format_hint=format_hint, columns=columns, **kwargs)
         dfs: List[DuckDataFrame] = []
-        for f in _get_single_files(fp, self._fs, fp[0].file_format):
+        for f in _get_files(fp, fp[0].file_format):
             df = self._format_load[f.file_format](f, columns, **kwargs)
             dfs.append(df)
         rel = dfs[0].native
@@ -83,26 +72,20 @@ class DuckDBIO:
         )
         p = FileParser(uri, format_hint).assert_no_glob()
         if (p.file_format not in self._format_save) or ("partition_cols" in kwargs):
-            self._fs.makedirs(os.path.dirname(uri), recreate=True)
+            makedirs(os.path.dirname(uri), exist_ok=True)
             ldf = ArrowDataFrame(df.as_arrow())
-            return save_df(
-                ldf, uri=uri, format_hint=format_hint, mode=mode, fs=self._fs, **kwargs
-            )
-        fs = self._fs
-        if fs.exists(uri):
+            return save_df(ldf, uri=uri, format_hint=format_hint, mode=mode, **kwargs)
+        if exists(uri):
             assert_or_throw(mode == "overwrite", FileExistsError(uri))
             try:
-                fs.remove(uri)
-            except Exception:
-                try:
-                    fs.removetree(uri)
-                except Exception:  # pragma: no cover
-                    pass
-        if not fs.exists(p.parent):
-            fs.makedirs(p.parent, recreate=True)
+                rm(uri, recursive=True)
+            except Exception:  # pragma: no cover
+                pass
+        p.make_parent_dirs()
         self._format_save[p.file_format](df, p, **kwargs)
 
     def _save_csv(self, df: DuckDataFrame, p: FileParser, **kwargs: Any):
+        p.assert_no_glob()
         dn = TempTableName()
         df.native.create_view(dn.key)
         kw = ParamDict({k.lower(): v for k, v in kwargs.items()})
@@ -111,7 +94,7 @@ class DuckDBIO:
         for k, v in kw.items():
             params.append(f"{k.upper()} " + encode_value_to_expr(v))
         pm = ", ".join(params)
-        query = f"COPY {dn.key} TO {encode_value_to_expr(p.uri)} WITH ({pm})"
+        query = f"COPY {dn.key} TO {encode_value_to_expr(p.path)} WITH ({pm})"
         self._con.execute(query)
 
     def _load_csv(  # noqa: C901
@@ -125,7 +108,7 @@ class DuckDBIO:
             ValueError("when csv has no header, columns must be specified"),
         )
         kw.pop("auto_detect", None)
-        params: List[str] = [encode_value_to_expr(p.uri_with_glob)]
+        params: List[str] = [encode_value_to_expr(p.path)]
         kw["header"] = 1 if header else 0
         kw["auto_detect"] = 1 if infer_schema else 0
         if infer_schema:
@@ -188,6 +171,7 @@ class DuckDBIO:
                 return DuckDataFrame(self._con.from_query(query))
 
     def _save_parquet(self, df: DuckDataFrame, p: FileParser, **kwargs: Any):
+        p.assert_no_glob()
         dn = TempTableName()
         df.native.create_view(dn.key)
         kw = ParamDict({k.lower(): v for k, v in kwargs.items()})
@@ -196,7 +180,7 @@ class DuckDBIO:
         for k, v in kw.items():
             params.append(f"{k.upper()} " + encode_value_to_expr(v))
         pm = ", ".join(params)
-        query = f"COPY {dn.key} TO {encode_value_to_expr(p.uri)}"
+        query = f"COPY {dn.key} TO {encode_value_to_expr(p.path)}"
         if len(params) > 0:
             query += f" WITH ({pm})"
         self._con.execute(query)
@@ -205,7 +189,7 @@ class DuckDBIO:
         self, p: FileParser, columns: Any = None, **kwargs: Any
     ) -> DuckDataFrame:
         kw = ParamDict({k.lower(): v for k, v in kwargs.items()})
-        params: List[str] = [encode_value_to_expr(p.uri_with_glob)]
+        params: List[str] = [encode_value_to_expr(p.path)]
         if isinstance(columns, list):
             cols = ", ".join(encode_column_names(columns))
         else: