revert(datasets): remove changes unrelated to mode

Signed-off-by: Deepyaman Datta <[email protected]>

Author: deepyaman

kedro-datasets/RELEASE.md

@@ -9,7 +9,6 @@
 | `polars.PolarsDatabaseDataset` | A dataset to load and save data to a SQL backend using Polars | `kedro_datasets_experimental.polars` |
 
 - `ibis.TableDataset`: Added configurable save modes via `save_args.mode`, supporting "append", "overwrite", "error"/"errorifexists", and "ignore". Legacy `save_args.overwrite` is mapped to `mode` for backward compatibility; specifying both is now an error.
-- `ibis.TableDataset`: Added a `credentials` parameter (string URI or dict, optionally with `con`) that supersedes the `connection` parameter. If both are provided, `credentials` takes precedence and a deprecation warning is issued.
 
 ## Bug fixes and other changes
 

kedro-datasets/kedro_datasets/ibis/table_dataset.py

@@ -85,7 +85,6 @@ def __init__(  # noqa: PLR0913
         *,
         table_name: str,
         database: str | None = None,
-        credentials: dict[str, Any] | str | None = None,
         connection: dict[str, Any] | None = None,
         load_args: dict[str, Any] | None = None,
         save_args: dict[str, Any] | None = None,
@@ -117,10 +116,6 @@ def __init__(  # noqa: PLR0913
                 in a multi-level table hierarchy.
             connection: Configuration for connecting to an Ibis backend.
                 If not provided, connect to DuckDB in in-memory mode.
-            credentials: Connection information (e.g.
-                user, password, token, account). If provided, these values
-                overlay the base `connection` configuration. May also be a
-                connection string.
             load_args: Additional arguments passed to the Ibis backend's
                 `read_{file_format}` method.
             save_args: Additional arguments passed to the Ibis backend's
@@ -139,32 +134,7 @@ def __init__(  # noqa: PLR0913
 
         self._table_name = table_name
         self._database = database
-        self._credentials = deepcopy(credentials) or {}
-        if self._credentials != {}:
-            self._backend_name = self._get_backend_name()
-
-        # Prefer credentials if provided, else fallback to connection.
-        self._connection_config = connection or (
-            self.DEFAULT_CONNECTION_CONFIG if self._credentials == {} else {}
-        )
-        if self._credentials is not None:
-            if isinstance(self._credentials, str):
-                self._connection_config.update(
-                    {
-                        "backend": self._backend_name,
-                        "con": self._credentials,
-                    }
-                )
-            elif (
-                isinstance(self._credentials, dict)
-                and "backend" not in self._credentials
-                and "con" in self._credentials
-            ):
-                self._connection_config.update(
-                    self._credentials | {"backend": self._backend_name}
-                )
-            else:
-                self._connection_config.update(self._credentials)
+        self._connection_config = connection or self.DEFAULT_CONNECTION_CONFIG
         self.metadata = metadata
 
         # Set load and save arguments, overwriting defaults if provided.
@@ -201,10 +171,6 @@ def _connect(self) -> BaseBackend:
         import ibis  # noqa: PLC0415
 
         config = deepcopy(self._connection_config)
-        # If credentials is a dict with a 'con' key, treat as connection string
-        if isinstance(config, dict) and "con" in config:
-            return ibis.connect(config.pop("con"))
-        # Otherwise, treat as expanded dict (params)
         backend = getattr(ibis, config.pop("backend"))
         return backend.connect(**config)
 
@@ -216,12 +182,7 @@ def connection(self) -> BaseBackend:
     def load(self) -> ir.Table:
         return self.connection.table(self._table_name, **self._load_args)
 
-    # Users should wrap their DataFrame-like object in an ibis.memtable for in-memory data.
-    # https://github.com/ibis-project/ibis/blob/df4f1858e7f9bc36d589dcf2a53f9f16b1acd92a/ibis/backends/duckdb/__init__.py#L180
     def save(self, data: ir.Table) -> None:
-        # treat empty ir.Table as a no-op
-        if isinstance(data, ir.Table) and data.count().execute() == 0:
-            return
         writer = getattr(self.connection, f"create_{self._materialized}")
         if self._mode == "append":
             if not self._exists():
@@ -243,22 +204,6 @@ def save(self, data: ir.Table) -> None:
                 return
             writer(self._table_name, data, overwrite=False, **self._save_args)
 
-    def _get_backend_name(self) -> str | None:
-        """Get the backend name from the connection config or connection string."""
-        config = self._credentials
-        # If dict and has 'backend'
-        if isinstance(config, dict) and "backend" in config:
-            return config["backend"]
-        # If string, parse as backend://...
-        if isinstance(config, str):
-            if "://" in config:
-                return config.split("://", 1)[0]
-        # If dict with 'con' key
-        if isinstance(config, dict) and "con" in config:
-            con_str = config["con"]
-            if "://" in con_str:
-                return con_str.split("://", 1)[0]
-
     def _describe(self) -> dict[str, Any]:
         load_args = deepcopy(self._load_args)
         save_args = deepcopy(self._save_args)
@@ -267,7 +212,7 @@ def _describe(self) -> dict[str, Any]:
         return {
             "table_name": self._table_name,
             "database": self._database,
-            "backend": self.connection.name,
+            "backend": self._connection_config["backend"],
             "load_args": load_args,
             "save_args": save_args,
             "materialized": self._materialized,

kedro-datasets/tests/ibis/conftest.py

@@ -37,39 +37,17 @@ def connection_config(request, database):
     )
 
 
-@pytest.fixture(params=[_SENTINEL])
-def credentials_config(request, database):
-    return (
-        None
-        if request.param is _SENTINEL  # `None` is a valid value to test
-        else request.param
-    )
-
-
 @pytest.fixture(params=[_SENTINEL])
 def table_name(request):
     # Default table name when not explicitly parametrized
     return "test" if request.param is _SENTINEL else request.param
 
 
-# @pytest.fixture(params=['test'])
-# def table_name(request):
-#     return request.param
-
-
 @pytest.fixture
-def table_dataset(
-    database_name,
-    credentials_config,
-    connection_config,
-    load_args,
-    save_args,
-    table_name,
-):
+def table_dataset(table_name, database_name, connection_config, load_args, save_args):
     return TableDataset(
         table_name=table_name,
         database=database_name,
-        credentials=credentials_config,
         connection=connection_config,
         load_args=load_args,
         save_args=save_args,
@@ -260,17 +238,6 @@ def test_describe_includes_backend_mode_and_materialized(self, table_dataset):
         assert "database" not in desc["load_args"]
         assert "database" not in desc["save_args"]
 
-    @pytest.mark.parametrize(
-        "save_args",
-        [{"materialized": "table"}],
-        indirect=True,
-    )
-    def test_save_empty_dataframe_is_noop(self, table_dataset):
-        """Saving an empty DataFrame should be a no-op (no table created)."""
-        empty_table = ibis.memtable(pd.DataFrame({"col1": [], "col2": [], "col3": []}))
-        table_dataset.save(empty_table)
-        assert not table_dataset.exists()
-
     @pytest.mark.parametrize("load_args", [{"database": "test"}], indirect=True)
     def test_load_extra_params(self, table_dataset, load_args):
         """Test overriding the default load arguments."""
@@ -378,100 +345,9 @@ def test_connection_config(self, mocker, table_dataset, connection_config, key):
         table_dataset.load()
         assert ("ibis", key) in table_dataset._connections
 
-    @pytest.mark.parametrize(
-        ("credentials_config", "key"),
-        [
-            (
-                "postgres://xxxxxx.postgres.database.azure.com:5432/postgres",
-                (
-                    ("backend", "postgres"),
-                    (
-                        "con",
-                        "postgres://xxxxxx.postgres.database.azure.com:5432/postgres",
-                    ),
-                ),
-            ),
-            (
-                {
-                    "con": "postgres://[email protected]:5432/postgres"
-                },
-                (
-                    ("backend", "postgres"),
-                    (
-                        "con",
-                        "postgres://[email protected]:5432/postgres",
-                    ),
-                ),
-            ),
-            (
-                {
-                    "backend": "postgres",
-                    "database": "postgres",
-                    "host": "xxxx.postgres.database.azure.com",
-                },
-                (
-                    ("backend", "postgres"),
-                    ("database", "postgres"),
-                    ("host", "xxxx.postgres.database.azure.com"),
-                ),
-            ),
-        ],
-    )
-    @pytest.mark.parametrize("connection_config", [None], indirect=True)
-    def test_connection_config_with_credentials(
-        self, mocker, table_dataset, credentials_config, key
-    ):
-        # 1) isolate the cache so parametrized cases don't reuse connections
-
-        if isinstance(credentials_config, str) or "backend" not in credentials_config:
-            backend = "postgres"
-        else:
-            backend = credentials_config["backend"]
-
-        mocker.patch(f"ibis.{backend}")
-        conn = table_dataset.connection
-        assert conn is not None
-        table_dataset.load()
-        assert ("ibis", key) in table_dataset._connections
-
     def test_save_data_loaded_using_file_dataset(self, file_dataset, table_dataset):
         """Test interoperability of Ibis datasets sharing a database."""
         dummy_table = file_dataset.load()
         assert not table_dataset.exists()
         table_dataset.save(dummy_table)
         assert table_dataset.exists()
-
-    # Additional tests for _get_backend_name branch coverage
-    class TestGetBackendName:
-        def test_get_backend_name_dict_with_backend(self):
-            ds = TableDataset(table_name="t")
-            ds._credentials = {"backend": "postgres", "database": "db"}
-            assert ds._get_backend_name() == "postgres"
-
-        def test_get_backend_name_dict_without_backend_or_con(self):
-            ds = TableDataset(table_name="t")
-            ds._credentials = {"user": "u", "password": "p"}
-            assert ds._get_backend_name() is None
-
-        def test_get_backend_name_string_with_scheme(self):
-            ds = TableDataset(table_name="t")
-            ds._credentials = "mysql://xxxxxx@host:3306/dbname"
-            assert ds._get_backend_name() == "mysql"
-
-        def test_get_backend_name_string_without_scheme(self):
-            ds = TableDataset(table_name="t")
-            ds._credentials = "not_a_url_string"
-            assert ds._get_backend_name() is None
-
-        def test_get_backend_name_dict_with_con_and_scheme(self):
-            ds = TableDataset(table_name="t")
-            ds._credentials = {
-                "con": "postgres://xxxxxx@host:5432/dbname",
-                "some_other": "value",
-            }
-            assert ds._get_backend_name() == "postgres"
-
-        def test_get_backend_name_dict_with_con_without_scheme(self):
-            ds = TableDataset(table_name="t")
-            ds._credentials = {"con": "sqlite_memory"}
-            assert ds._get_backend_name() is None