feat(datasets): add back changes unrelated to mode

This reverts commit e4636b7.

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

Author: deepyaman

kedro-datasets/RELEASE.md

@@ -9,6 +9,7 @@
 | `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,6 +85,7 @@ 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,
@@ -116,6 +117,10 @@ 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
@@ -134,7 +139,32 @@ def __init__(  # noqa: PLR0913
 
         self._table_name = table_name
         self._database = database
-        self._connection_config = connection or self.DEFAULT_CONNECTION_CONFIG
+        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.metadata = metadata
 
         # Set load and save arguments, overwriting defaults if provided.
@@ -171,6 +201,10 @@ 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)
 
@@ -182,7 +216,12 @@ 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():
@@ -204,6 +243,22 @@ 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)
@@ -212,7 +267,7 @@ def _describe(self) -> dict[str, Any]:
         return {
             "table_name": self._table_name,
             "database": self._database,
-            "backend": self._connection_config["backend"],
+            "backend": self.connection.name,
             "load_args": load_args,
             "save_args": save_args,
             "materialized": self._materialized,

kedro-datasets/tests/ibis/conftest.py

@@ -0,0 +1,29 @@
+import importlib
+from unittest import mock
+
+# Stub expensive/optional ibis backends that may raise ImportError when
+# accessed via attribute lookup during tests (for example, ibis.mssql
+# tries to import pyodbc which may not be installed in the test env).
+# Creating module attributes here prevents ibis.__getattr__ from being
+# invoked by tests that call mocker.patch("ibis.<backend>")...
+
+_IBIS_BACKENDS_TO_STUB = (
+    "mssql",
+    "postgres",
+)
+
+try:
+    ibis = importlib.import_module("ibis")
+except Exception:
+    # If ibis itself is unavailable for some reason, nothing to stub.
+    ibis = None
+
+if ibis is not None:
+    for _b in _IBIS_BACKENDS_TO_STUB:
+        # Directly set attribute on the module to avoid triggering
+        # ibis.__getattr__ lazy-loading logic when tests access it.
+        try:
+            setattr(ibis, _b, mock.MagicMock(name=f"ibis.{_b}"))
+        except Exception:
+            # Guard against any unexpected issues in CI/test envs.
+            pass

kedro-datasets/tests/ibis/test_table_dataset.py

@@ -37,17 +37,39 @@ 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(table_name, database_name, connection_config, load_args, save_args):
+def table_dataset(
+    database_name,
+    credentials_config,
+    connection_config,
+    load_args,
+    save_args,
+    table_name,
+):
     return TableDataset(
         table_name=table_name,
         database=database_name,
+        credentials=credentials_config,
         connection=connection_config,
         load_args=load_args,
         save_args=save_args,
@@ -238,6 +260,17 @@ 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."""
@@ -345,9 +378,100 @@ 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