deltacat 1.1.38__py3-none-any.whl → 2.0.0__py3-none-any.whl

deltacat/catalog/default_catalog_impl/__init__.py

@@ -1,369 +0,0 @@
-from typing import Any, Dict, List, Optional, Set, Union, Tuple
-import pyarrow as pa
-import logging
-from deltacat.catalog.model.table_definition import TableDefinition
-from deltacat.storage.model.sort_key import SortKey
-from deltacat.storage.model.list_result import ListResult
-from deltacat.storage.model.namespace import Namespace
-from deltacat.storage.model.types import (
-    DistributedDataset,
-    LifecycleState,
-    LocalDataset,
-    LocalTable,
-    SchemaConsistencyType,
-)
-from deltacat.storage.model.partition import PartitionLocator, Partition
-from deltacat.storage.model.table_version import TableVersion
-from deltacat.compute.merge_on_read.model.merge_on_read_params import MergeOnReadParams
-from deltacat.storage.model.delta import DeltaType
-import deltacat.storage.interface as deltacat_storage
-from deltacat.types.media import ContentType, TableType, DistributedDatasetType
-from deltacat.types.tables import TableWriteMode
-from deltacat.compute.merge_on_read import MERGE_FUNC_BY_DISTRIBUTED_DATASET_TYPE
-from deltacat import logs
-
-logger = logs.configure_deltacat_logger(logging.getLogger(__name__))
-
-STORAGE = None
-
-
-# table functions
-def write_to_table(
-    data: Union[LocalTable, LocalDataset, DistributedDataset],  # type: ignore
-    table: str,
-    namespace: Optional[str] = None,
-    mode: TableWriteMode = TableWriteMode.AUTO,
-    content_type: ContentType = ContentType.PARQUET,
-    *args,
-    **kwargs,
-) -> None:
-    """Write local or distributed data to a table. Raises an error if the
-    table does not exist and the table write mode is not CREATE or AUTO.
-
-    When creating a table, all `create_table` parameters may be optionally
-    specified as additional keyword arguments. When appending to, or replacing,
-    an existing table, all `alter_table` parameters may be optionally specified
-    as additional keyword arguments."""
-    raise NotImplementedError("write_to_table not implemented")
-
-
-def read_table(
-    table: str,
-    namespace: Optional[str] = None,
-    table_version: Optional[str] = None,
-    table_type: Optional[TableType] = TableType.PYARROW,
-    distributed_dataset_type: Optional[
-        DistributedDatasetType
-    ] = DistributedDatasetType.RAY_DATASET,
-    partition_filter: Optional[List[Union[Partition, PartitionLocator]]] = None,
-    stream_position_range_inclusive: Optional[Tuple[int, int]] = None,
-    merge_on_read: Optional[bool] = False,
-    reader_kwargs: Optional[Dict[Any, Any]] = None,
-    deltacat_storage_kwargs: Optional[Dict[Any, Any]] = None,
-    *args,
-    **kwargs,
-) -> DistributedDataset:  # type: ignore
-    """Read a table into a distributed dataset."""
-
-    if reader_kwargs is None:
-        reader_kwargs = {}
-
-    if deltacat_storage_kwargs is None:
-        deltacat_storage_kwargs = {}
-
-    _validate_read_table_args(
-        namespace=namespace,
-        table_type=table_type,
-        distributed_dataset_type=distributed_dataset_type,
-        merge_on_read=merge_on_read,
-    )
-
-    table_version_obj = _get_latest_or_given_table_version(
-        namespace=namespace,
-        table_name=table,
-        table_version=table_version,
-        **deltacat_storage_kwargs,
-    )
-    table_version = table_version_obj.table_version
-
-    if (
-        table_version_obj.content_types is None
-        or len(table_version_obj.content_types) != 1
-    ):
-        raise ValueError(
-            "Expected exactly one content type but "
-            f"found {table_version_obj.content_types}."
-        )
-
-    logger.info(
-        f"Reading metadata for table={namespace}/{table}/{table_version} "
-        f"with partition_filters={partition_filter} and stream position"
-        f" range={stream_position_range_inclusive}"
-    )
-
-    if partition_filter is None:
-        logger.info(
-            f"Reading all partitions metadata in the table={table} "
-            "as partition_filter was None."
-        )
-        partition_filter = STORAGE.list_partitions(
-            table_name=table,
-            namespace=namespace,
-            table_version=table_version,
-            **deltacat_storage_kwargs,
-        ).all_items()
-
-    qualified_deltas = _get_deltas_from_partition_filter(
-        stream_position_range_inclusive=stream_position_range_inclusive,
-        partition_filter=partition_filter,
-        **deltacat_storage_kwargs,
-    )
-
-    logger.info(
-        f"Total qualified deltas={len(qualified_deltas)} "
-        f"from {len(partition_filter)} partitions."
-    )
-
-    merge_on_read_params = MergeOnReadParams.of(
-        {
-            "deltas": qualified_deltas,
-            "deltacat_storage": STORAGE,
-            "deltacat_storage_kwargs": deltacat_storage_kwargs,
-            "reader_kwargs": reader_kwargs,
-        }
-    )
-
-    return MERGE_FUNC_BY_DISTRIBUTED_DATASET_TYPE[distributed_dataset_type.value](
-        params=merge_on_read_params, **kwargs
-    )
-
-
-def alter_table(
-    table: str,
-    namespace: Optional[str] = None,
-    lifecycle_state: Optional[LifecycleState] = None,
-    schema_updates: Optional[Dict[str, Any]] = None,
-    partition_updates: Optional[Dict[str, Any]] = None,
-    primary_keys: Optional[Set[str]] = None,
-    sort_keys: Optional[List[SortKey]] = None,
-    description: Optional[str] = None,
-    properties: Optional[Dict[str, str]] = None,
-    *args,
-    **kwargs,
-) -> None:
-    """Alter table definition."""
-    raise NotImplementedError("alter_table not implemented")
-
-
-def create_table(
-    table: str,
-    namespace: Optional[str] = None,
-    lifecycle_state: Optional[LifecycleState] = None,
-    schema: Optional[Union[pa.Schema, str, bytes]] = None,
-    schema_consistency: Optional[Dict[str, SchemaConsistencyType]] = None,
-    partition_keys: Optional[List[Dict[str, Any]]] = None,
-    primary_keys: Optional[Set[str]] = None,
-    sort_keys: Optional[List[SortKey]] = None,
-    description: Optional[str] = None,
-    properties: Optional[Dict[str, str]] = None,
-    permissions: Optional[Dict[str, Any]] = None,
-    content_types: Optional[List[ContentType]] = None,
-    replace_existing_table: bool = False,
-    *args,
-    **kwargs,
-) -> TableDefinition:
-    """Create an empty table. Raises an error if the table already exists and
-    `replace_existing_table` is False."""
-    raise NotImplementedError("create_table not implemented")
-
-
-def drop_table(
-    table: str, namespace: Optional[str] = None, purge: bool = False, *args, **kwargs
-) -> None:
-    """Drop a table from the catalog and optionally purge it. Raises an error
-    if the table does not exist."""
-    raise NotImplementedError("drop_table not implemented")
-
-
-def refresh_table(table: str, namespace: Optional[str] = None, *args, **kwargs) -> None:
-    """Refresh metadata cached on the Ray cluster for the given table."""
-    raise NotImplementedError("refresh_table not implemented")
-
-
-def list_tables(
-    namespace: Optional[str] = None, *args, **kwargs
-) -> ListResult[TableDefinition]:
-    """List a page of table definitions. Raises an error if the given namespace
-    does not exist."""
-    raise NotImplementedError("list_tables not implemented")
-
-
-def get_table(
-    table: str, namespace: Optional[str] = None, *args, **kwargs
-) -> Optional[TableDefinition]:
-    """Get table definition metadata. Returns None if the given table does not
-    exist."""
-    raise NotImplementedError("get_table not implemented")
-
-
-def truncate_table(
-    table: str, namespace: Optional[str] = None, *args, **kwargs
-) -> None:
-    """Truncate table data. Raises an error if the table does not exist."""
-    raise NotImplementedError("truncate_table not implemented")
-
-
-def rename_table(
-    table: str, new_name: str, namespace: Optional[str] = None, *args, **kwargs
-) -> None:
-    """Rename a table."""
-    raise NotImplementedError("rename_table not implemented")
-
-
-def table_exists(table: str, namespace: Optional[str] = None, *args, **kwargs) -> bool:
-    """Returns True if the given table exists, False if not."""
-    raise NotImplementedError("table_exists not implemented")
-
-
-# namespace functions
-def list_namespaces(*args, **kwargs) -> ListResult[Namespace]:
-    """List a page of table namespaces."""
-    raise NotImplementedError("list_namespaces not implemented")
-
-
-def get_namespace(namespace: str, *args, **kwargs) -> Optional[Namespace]:
-    """Gets table namespace metadata for the specified table namespace. Returns
-    None if the given namespace does not exist."""
-    raise NotImplementedError("get_namespace not implemented")
-
-
-def namespace_exists(namespace: str, *args, **kwargs) -> bool:
-    """Returns True if the given table namespace exists, False if not."""
-    raise NotImplementedError("namespace_exists not implemented")
-
-
-def create_namespace(
-    namespace: str, permissions: Dict[str, Any], *args, **kwargs
-) -> Namespace:
-    """Creates a table namespace with the given name and permissions. Returns
-    the created namespace. Raises an error if the namespace already exists."""
-    raise NotImplementedError("create_namespace not implemented")
-
-
-def alter_namespace(
-    namespace: str,
-    permissions: Optional[Dict[str, Any]] = None,
-    new_namespace: Optional[str] = None,
-    *args,
-    **kwargs,
-) -> None:
-    """Alter table namespace definition."""
-    raise NotImplementedError("alter_namespace not implemented")
-
-
-def drop_namespace(namespace: str, purge: bool = False, *args, **kwargs) -> None:
-    """Drop the given namespace and all of its tables from the catalog,
-    optionally purging them."""
-    raise NotImplementedError("drop_namespace not implemented")
-
-
-def default_namespace() -> str:
-    """Returns the default namespace for the catalog."""
-    raise NotImplementedError("default_namespace not implemented")
-
-
-# catalog functions
-def initialize(ds: deltacat_storage, *args, **kwargs) -> None:
-    """Initializes the data catalog with the given arguments."""
-    global STORAGE
-    STORAGE = ds
-
-
-def _validate_read_table_args(
-    namespace: Optional[str] = None,
-    table_type: Optional[TableType] = None,
-    distributed_dataset_type: Optional[DistributedDatasetType] = None,
-    merge_on_read: Optional[bool] = None,
-):
-    if STORAGE is None:
-        raise ValueError(
-            "Catalog not initialized. Did you miss calling "
-            "initialize(ds=<deltacat_storage>)?"
-        )
-
-    if merge_on_read:
-        raise ValueError("Merge on read not supported currently.")
-
-    if table_type is not TableType.PYARROW:
-        raise ValueError("Only PYARROW table type is supported as of now")
-
-    if distributed_dataset_type is not DistributedDatasetType.DAFT:
-        raise ValueError("Only DAFT dataset type is supported as of now")
-
-    if namespace is None:
-        raise ValueError(
-            "namespace must be passed to uniquely identify a table in the catalog."
-        )
-
-
-def _get_latest_or_given_table_version(
-    namespace: str,
-    table_name: str,
-    table_version: Optional[str] = None,
-    *args,
-    **kwargs,
-) -> TableVersion:
-    table_version_obj = None
-    if table_version is None:
-        table_version_obj = STORAGE.get_latest_table_version(
-            namespace=namespace, table_name=table_name, *args, **kwargs
-        )
-        table_version = table_version_obj.table_version
-    else:
-        table_version_obj = STORAGE.get_table_version(
-            namespace=namespace,
-            table_name=table_name,
-            table_version=table_version,
-            *args,
-            **kwargs,
-        )
-
-    return table_version_obj
-
-
-def _get_deltas_from_partition_filter(
-    partition_filter: Optional[List[Union[Partition, PartitionLocator]]] = None,
-    stream_position_range_inclusive: Optional[Tuple[int, int]] = None,
-    *args,
-    **kwargs,
-):
-
-    result_deltas = []
-    start_stream_position, end_stream_position = stream_position_range_inclusive or (
-        None,
-        None,
-    )
-    for partition_like in partition_filter:
-        deltas = STORAGE.list_partition_deltas(
-            partition_like=partition_like,
-            ascending_order=True,
-            include_manifest=True,
-            start_stream_position=start_stream_position,
-            last_stream_position=end_stream_position,
-            *args,
-            **kwargs,
-        ).all_items()
-
-        for delta in deltas:
-            if (
-                start_stream_position is None
-                or delta.stream_position >= start_stream_position
-            ) and (
-                end_stream_position is None
-                or delta.stream_position <= end_stream_position
-            ):
-                if delta.type == DeltaType.DELETE:
-                    raise ValueError("DELETE type deltas are not supported")
-                result_deltas.append(delta)
-
-    return result_deltas

deltacat/compute/compactor/utils/round_completion_file.py

@@ -1,97 +0,0 @@
-import json
-import logging
-from typing import Dict, Any
-from deltacat import logs
-from deltacat.compute.compactor import RoundCompletionInfo
-from deltacat.storage import PartitionLocator
-from deltacat.aws import s3u as s3_utils
-from typing import Optional
-from deltacat.utils.metrics import metrics
-
-logger = logs.configure_deltacat_logger(logging.getLogger(__name__))
-
-
-def get_round_completion_file_s3_url(
-    bucket: str,
-    source_partition_locator: PartitionLocator,
-    destination_partition_locator: Optional[PartitionLocator] = None,
-) -> str:
-
-    base_url = source_partition_locator.path(f"s3://{bucket}")
-    if destination_partition_locator:
-        base_url = destination_partition_locator.path(
-            f"s3://{bucket}/{source_partition_locator.hexdigest()}"
-        )
-
-    return f"{base_url}.json"
-
-
-@metrics
-def read_round_completion_file(
-    bucket: str,
-    source_partition_locator: PartitionLocator,
-    destination_partition_locator: Optional[PartitionLocator] = None,
-    **s3_client_kwargs: Optional[Dict[str, Any]],
-) -> RoundCompletionInfo:
-
-    all_uris = []
-    if destination_partition_locator:
-        round_completion_file_url_with_destination = get_round_completion_file_s3_url(
-            bucket,
-            source_partition_locator,
-            destination_partition_locator,
-        )
-        all_uris.append(round_completion_file_url_with_destination)
-
-    # Note: we read from RCF at two different URI for backward
-    # compatibility reasons.
-    round_completion_file_url_prev = get_round_completion_file_s3_url(
-        bucket,
-        source_partition_locator,
-    )
-
-    all_uris.append(round_completion_file_url_prev)
-
-    round_completion_info = None
-
-    for rcf_uri in all_uris:
-        logger.info(f"Reading round completion file from: {rcf_uri}")
-        result = s3_utils.download(rcf_uri, False, **s3_client_kwargs)
-        if result:
-            json_str = result["Body"].read().decode("utf-8")
-            round_completion_info = RoundCompletionInfo(json.loads(json_str))
-            logger.info(f"Read round completion info: {round_completion_info}")
-            break
-        else:
-            logger.warning(f"Round completion file not present at {rcf_uri}")
-
-    return round_completion_info
-
-
-@metrics
-def write_round_completion_file(
-    bucket: Optional[str],
-    source_partition_locator: Optional[PartitionLocator],
-    destination_partition_locator: Optional[PartitionLocator],
-    round_completion_info: RoundCompletionInfo,
-    completion_file_s3_url: Optional[str] = None,
-    **s3_client_kwargs: Optional[Dict[str, Any]],
-) -> str:
-    if bucket is None and completion_file_s3_url is None:
-        raise AssertionError("Either bucket or completion_file_s3_url must be passed")
-
-    logger.info(f"writing round completion file contents: {round_completion_info}")
-    if completion_file_s3_url is None:
-        completion_file_s3_url = get_round_completion_file_s3_url(
-            bucket,
-            source_partition_locator,
-            destination_partition_locator,
-        )
-    logger.info(f"writing round completion file to: {completion_file_s3_url}")
-    s3_utils.upload(
-        completion_file_s3_url,
-        str(json.dumps(round_completion_info)),
-        **s3_client_kwargs,
-    )
-    logger.info(f"round completion file written to: {completion_file_s3_url}")
-    return completion_file_s3_url

deltacat/compute/merge_on_read/__init__.py

@@ -1,4 +0,0 @@
-from deltacat.types.media import DistributedDatasetType
-from deltacat.compute.merge_on_read.daft import merge as daft_merge
-
-MERGE_FUNC_BY_DISTRIBUTED_DATASET_TYPE = {DistributedDatasetType.DAFT.value: daft_merge}

deltacat/compute/merge_on_read/daft.py

@@ -1,40 +0,0 @@
-import logging
-from deltacat.compute.merge_on_read.model.merge_on_read_params import MergeOnReadParams
-from deltacat.storage.model.types import DistributedDataset
-from deltacat.types.media import TableType, DistributedDatasetType
-from deltacat.compute.merge_on_read.utils.delta import create_df_from_all_deltas
-from deltacat import logs
-
-logger = logs.configure_deltacat_logger(logging.getLogger(__name__))
-
-
-def merge(params: MergeOnReadParams, **kwargs) -> DistributedDataset:
-    """
-    Merges the given deltas and returns the result as distributed dataframe.
-    It reads the deltas into the Daft dataframe and leverages operations supported
-    by Daft to perform an efficient merge using Ray cluster.
-
-    TODO(raghumdani): Perform actual merge.
-    """
-
-    delta_dfs = create_df_from_all_deltas(
-        deltas=params.deltas,
-        table_type=TableType.PYARROW,
-        distributed_dataset_type=DistributedDatasetType.DAFT,
-        reader_kwargs=params.reader_kwargs,
-        deltacat_storage=params.deltacat_storage,
-        deltacat_storage_kwargs=params.deltacat_storage_kwargs,
-        **kwargs,
-    )
-
-    logger.info(f"Merging {len(delta_dfs)} delta dfs...")
-
-    # TODO: This code should be optimized from daft side
-    result = None
-    for df in delta_dfs:
-        if result is None:
-            result = df
-        else:
-            result = result.concat(df)
-
-    return result

deltacat/compute/merge_on_read/model/merge_on_read_params.py

@@ -1,66 +0,0 @@
-from __future__ import annotations
-from typing import Optional, Dict, List, Union, Any
-from deltacat.storage import (
-    Delta,
-    DeltaLocator,
-    interface as unimplemented_deltacat_storage,
-)
-
-
-class MergeOnReadParams(dict):
-    """
-    This class represents the parameters passed to compact_partition (deltacat/compute/compactor/compaction_session.py)
-    """
-
-    @staticmethod
-    def of(params: Optional[Dict]) -> MergeOnReadParams:
-        params = {} if params is None else params
-
-        result = MergeOnReadParams(params)
-        assert result.deltas is not None, "deltas is a required arg"
-
-        result.deltacat_storage = params.get(
-            "deltacat_storage", unimplemented_deltacat_storage
-        )
-        result.reader_kwargs = params.get("reader_kwargs", {})
-        result.deltacat_storage_kwargs = params.get("deltacat_storage_kwargs", {})
-
-        return result
-
-    @property
-    def deltas(self) -> List[Union[Delta, DeltaLocator]]:
-        """
-        The list of deltas to compact in-memory.
-        """
-        return self["deltas"]
-
-    @deltas.setter
-    def deltas(self, to_set: List[Union[Delta, DeltaLocator]]) -> None:
-        self["deltas"] = to_set
-
-    @property
-    def reader_kwargs(self) -> Dict[Any, Any]:
-        """
-        The key word arguments to be passed to the reader.
-        """
-        return self["reader_kwargs"]
-
-    @reader_kwargs.setter
-    def reader_kwargs(self, kwargs: Dict[Any, Any]) -> None:
-        self["reader_kwargs"] = kwargs
-
-    @property
-    def deltacat_storage(self) -> unimplemented_deltacat_storage:
-        return self["deltacat_storage"]
-
-    @deltacat_storage.setter
-    def deltacat_storage(self, storage: unimplemented_deltacat_storage) -> None:
-        self["deltacat_storage"] = storage
-
-    @property
-    def deltacat_storage_kwargs(self) -> dict:
-        return self["deltacat_storage_kwargs"]
-
-    @deltacat_storage_kwargs.setter
-    def deltacat_storage_kwargs(self, kwargs: dict) -> None:
-        self["deltacat_storage_kwargs"] = kwargs

deltacat/compute/merge_on_read/utils/delta.py

@@ -1,42 +0,0 @@
-from typing import List, Dict, Any, Optional, Union
-from deltacat.storage.model.delta import Delta, DeltaLocator
-from deltacat.storage.model.types import DistributedDataset
-from deltacat.storage import (
-    interface as unimplemented_deltacat_storage,
-)
-from deltacat.types.media import TableType, StorageType, DistributedDatasetType
-
-
-def create_df_from_all_deltas(
-    deltas: List[Union[Delta, DeltaLocator]],
-    table_type: TableType,
-    distributed_dataset_type: DistributedDatasetType,
-    reader_kwargs: Optional[Dict[Any, Any]] = None,
-    deltacat_storage=unimplemented_deltacat_storage,
-    deltacat_storage_kwargs: Optional[Dict[Any, Any]] = None,
-    *args,
-    **kwargs
-) -> List[DistributedDataset]:  # type: ignore
-    """
-    This method creates a distributed dataset for each delta and returns their references.
-    """
-
-    if reader_kwargs is None:
-        reader_kwargs = {}
-    if deltacat_storage_kwargs is None:
-        deltacat_storage_kwargs = {}
-
-    df_list = []
-
-    for delta in deltas:
-        df = deltacat_storage.download_delta(
-            delta_like=delta,
-            table_type=table_type,
-            distributed_dataset_type=distributed_dataset_type,
-            storage_type=StorageType.DISTRIBUTED,
-            **reader_kwargs,
-            **deltacat_storage_kwargs
-        )
-        df_list.append(df)
-
-    return df_list

deltacat/io/dataset.py

@@ -1,73 +0,0 @@
-# Allow classes to use self-referencing Type hints in Python 3.7.
-from __future__ import annotations
-
-from typing import Any, Callable, Dict, Optional, TypeVar, Union, cast
-
-import pyarrow as pa
-import s3fs
-from ray.data import Dataset
-
-T = TypeVar("T")
-
-
-class DeltacatDataset(Dataset[T]):
-    @staticmethod
-    def from_dataset(dataset: Dataset[T]) -> DeltacatDataset[T]:
-        # cast to DeltacatDataset in-place since it only adds new methods
-        dataset.__class__ = DeltacatDataset
-        return cast(DeltacatDataset[T], dataset)
-
-    def write_redshift(
-        self,
-        path: str,
-        *,
-        filesystem: Optional[Union[pa.fs.FileSystem, s3fs.S3FileSystem]] = None,
-        try_create_dir: bool = True,
-        arrow_open_stream_args: Optional[Dict[str, Any]] = None,
-        arrow_parquet_args_fn: Callable[[], Dict[str, Any]] = lambda: {},
-        **arrow_parquet_args,
-    ) -> None:
-        """Writes the dataset to Parquet files and commits a Redshift manifest
-        back to S3 indexing the files written. The output can be loaded into
-        Redshift by providing it to the Redshift COPY command, or via AWS Data
-        Wrangler's `wr.redshift.copy_from_files()` API.
-
-        This is only supported for datasets convertible to Arrow records.
-        To control the number of files, use ``.repartition()``.
-
-        Unless a custom block path provider is given, the format of the output
-        files will be {uuid}_{block_idx}.parquet, where ``uuid`` is an unique
-        id for the dataset.
-
-        The Redshift manifest will be written to ``f"{path}/manifest``
-
-        Examples:
-            >>> ds.write_redshift("s3://bucket/path")
-
-        Time complexity: O(dataset size / parallelism)
-
-        Args:
-            path: The path to the destination root directory where Parquet
-                files and the Redshift manifest will be written to.
-            filesystem: The filesystem implementation to write to. This should
-                be either PyArrow's S3FileSystem or s3fs.
-            try_create_dir: Try to create all directories in destination path
-                if True. Does nothing if all directories already exist.
-            arrow_open_stream_args: kwargs passed to
-                pyarrow.fs.FileSystem.open_output_stream
-            filename_provider: FilenameProvider implementation
-                to write each dataset block to a custom output path.
-            arrow_parquet_args_fn: Callable that returns a dictionary of write
-                arguments to use when writing each block to a file. Overrides
-                any duplicate keys from arrow_parquet_args. This should be used
-                instead of arrow_parquet_args if any of your write arguments
-                cannot be pickled, or if you'd like to lazily resolve the write
-                arguments for each dataset block.
-            arrow_parquet_args: Options to pass to
-                pyarrow.parquet.write_table(), which is used to write out each
-                block to a file.
-        """
-        raise NotImplementedError(
-            "Writing to Redshift is not yet supported. "
-            "Please use DeltacatDataset.write_parquet() instead."
-        )