Address PR review: rename database.dbname → database.name, deprecate database_prefix

Review feedback from PR #1426:

1. Rename setting to database.name (env: DJ_DATABASE_NAME) to match
   section naming style and avoid stutter. Connection kwarg is
   database_name. Adapter still receives dbname (psycopg2's parameter).

2. Deprecate database_prefix — emit DeprecationWarning when non-empty.
   Will be removed in DataJoint 2.3. database.name is the replacement.

3. Revert version.py to 2.2.0 — release workflow owns version bumps.

4. Warn when database.name is set with MySQL backend (MySQL does not
   support database selection via this parameter).

5. Include database name in Connection.__repr__ and log message when set.
   Format: user@host:port/database_name

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: kushalbakshi

src/datajoint/connection.py

@@ -168,7 +168,7 @@ def __init__(
         port: int | None = None,
         use_tls: bool | dict | None = None,
         *,
-        dbname: str | None = None,
+        database_name: str | None = None,
         backend: str | None = None,
         config_override: "Config | None" = None,
     ) -> None:
@@ -181,9 +181,9 @@ def __init__(
             port = int(port)
         elif port is None:
             port = self._config["database.port"]
-        if dbname is None:
-            dbname = self._config.get("database.dbname")
-        self.conn_info = dict(host=host, port=port, user=user, passwd=password, dbname=dbname)
+        if database_name is None:
+            database_name = self._config.get("database.name")
+        self.conn_info = dict(host=host, port=port, user=user, passwd=password, database_name=database_name)
         if use_tls is not False:
             # use_tls can be: None (auto-detect), True (enable), False (disable), or dict (custom config)
             if isinstance(use_tls, dict):
@@ -204,12 +204,27 @@ def __init__(
             backend = self._config["database.backend"]
         self.adapter = get_adapter(backend)
 
+        if database_name and self.adapter.backend == "mysql":
+            warnings.warn(
+                "database.name is set but the MySQL backend does not support database selection. "
+                "This setting only applies to PostgreSQL connections.",
+                UserWarning,
+                stacklevel=2,
+            )
+
         self.connect()
         if self.is_connected:
-            logger.info("DataJoint {version} connected to {user}@{host}:{port}".format(version=__version__, **self.conn_info))
+            db = self.conn_info.get("database_name")
+            db_str = f"/{db}" if db else ""
+            logger.info(
+                f"DataJoint {__version__} connected to "
+                f"{self.conn_info['user']}@{self.conn_info['host']}:{self.conn_info['port']}{db_str}"
+            )
             self.connection_id = self.adapter.get_connection_id(self._conn)
         else:
-            raise errors.LostConnectionError("Connection failed {user}@{host}:{port}".format(**self.conn_info))
+            raise errors.LostConnectionError(
+                f"Connection failed {self.conn_info['user']}@{self.conn_info['host']}:{self.conn_info['port']}"
+            )
         self._in_transaction = False
         self.schemas = dict()
         self.dependencies = Dependencies(self)
@@ -219,7 +234,9 @@ def __eq__(self, other):
 
     def __repr__(self):
         connected = "connected" if self.is_connected else "disconnected"
-        return "DataJoint connection ({connected}) {user}@{host}:{port}".format(connected=connected, **self.conn_info)
+        db = self.conn_info.get("database_name")
+        db_str = f"/{db}" if db else ""
+        return f"DataJoint connection ({connected}) {self.conn_info['user']}@{self.conn_info['host']}:{self.conn_info['port']}{db_str}"
 
     def _build_connect_kwargs(self, use_tls=None):
         """Build kwargs dict for adapter.connect()."""
@@ -231,8 +248,8 @@ def _build_connect_kwargs(self, use_tls=None):
             charset=self._config["connection.charset"],
             use_tls=use_tls if use_tls is not None else self.conn_info.get("ssl"),
         )
-        if self.conn_info.get("dbname"):
-            kwargs["dbname"] = self.conn_info["dbname"]
+        if self.conn_info.get("database_name"):
+            kwargs["dbname"] = self.conn_info["database_name"]
         return kwargs
 
     def connect(self) -> None:

src/datajoint/settings.py

@@ -65,6 +65,7 @@
     "database.password": "DJ_PASS",
     "database.backend": "DJ_BACKEND",
     "database.port": "DJ_PORT",
+    "database.name": "DJ_DATABASE_NAME",
     "database.database_prefix": "DJ_DATABASE_PREFIX",
     "database.create_tables": "DJ_CREATE_TABLES",
     "loglevel": "DJ_LOG_LEVEL",
@@ -196,18 +197,17 @@ class DatabaseSettings(BaseSettings):
         description="Database backend: 'mysql' or 'postgresql'",
     )
     port: int | None = Field(default=None, validation_alias="DJ_PORT")
-    dbname: str | None = Field(
+    name: str | None = Field(
         default=None,
-        validation_alias="DJ_DBNAME",
+        validation_alias="DJ_DATABASE_NAME",
         description="Database name for PostgreSQL connections. Defaults to 'postgres' if not set.",
     )
     reconnect: bool = True
     use_tls: bool | None = Field(default=None, validation_alias="DJ_USE_TLS")
     database_prefix: str = Field(
         default="",
         validation_alias="DJ_DATABASE_PREFIX",
-        description="Prefix for database/schema names. "
-        "Not automatically applied; use dj.config.database.database_prefix when creating schemas.",
+        description="Deprecated. Use database.name instead.",
     )
     create_tables: bool = Field(
         default=True,
@@ -223,6 +223,20 @@ def set_default_port_from_backend(self) -> "DatabaseSettings":
             self.port = 5432 if self.backend == "postgresql" else 3306
         return self
 
+    @model_validator(mode="after")
+    def warn_database_prefix_deprecated(self) -> "DatabaseSettings":
+        """Emit deprecation warning when database_prefix is set."""
+        if self.database_prefix:
+            import warnings
+
+            warnings.warn(
+                "database_prefix is deprecated and will be removed in DataJoint 2.3. "
+                "Use database.name to select a PostgreSQL database instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        return self
+
 
 class ConnectionSettings(BaseSettings):
     """Connection behavior settings."""

src/datajoint/version.py

@@ -1,4 +1,4 @@
 # version bump auto managed by Github Actions:
 # label_prs.yaml(prep), release.yaml(bump), post_release.yaml(edit)
 # manually set this version will be eventually overwritten by the above actions
-__version__ = "2.2.1"
+__version__ = "2.2.0"

tests/unit/test_settings.py

@@ -750,55 +750,84 @@ def test_similar_prefix_names_allowed(self):
             dj.config.stores.update(original_stores)
 
 
-class TestDbnameConfiguration:
-    """Test database.dbname configuration."""
+class TestDatabaseNameConfiguration:
+    """Test database.name configuration."""
 
-    def test_dbname_default_is_none(self):
-        """Dbname defaults to None when not configured."""
+    def test_database_name_default_is_none(self):
+        """Database name defaults to None when not configured."""
         from datajoint.settings import DatabaseSettings
 
         s = DatabaseSettings()
-        assert s.dbname is None
+        assert s.name is None
 
-    def test_dbname_env_var(self, monkeypatch):
-        """DJ_DBNAME environment variable sets dbname."""
+    def test_database_name_env_var(self, monkeypatch):
+        """DJ_DATABASE_NAME environment variable sets database name."""
         from datajoint.settings import DatabaseSettings
 
-        monkeypatch.setenv("DJ_DBNAME", "my_database")
+        monkeypatch.setenv("DJ_DATABASE_NAME", "my_database")
         s = DatabaseSettings()
-        assert s.dbname == "my_database"
+        assert s.name == "my_database"
 
-    def test_dbname_from_config_file(self, tmp_path, monkeypatch):
-        """Load dbname from config file."""
+    def test_database_name_from_config_file(self, tmp_path, monkeypatch):
+        """Load database name from config file."""
         import json
 
         from datajoint.settings import Config
 
         config_file = tmp_path / "test_config.json"
-        config_file.write_text(json.dumps({"database": {"dbname": "custom_db", "host": "localhost"}}))
+        config_file.write_text(json.dumps({"database": {"name": "custom_db", "host": "localhost"}}))
 
-        monkeypatch.delenv("DJ_DBNAME", raising=False)
+        monkeypatch.delenv("DJ_DATABASE_NAME", raising=False)
         monkeypatch.delenv("DJ_HOST", raising=False)
 
         cfg = Config()
         cfg.load(config_file)
-        assert cfg.database.dbname == "custom_db"
+        assert cfg.database.name == "custom_db"
 
-    def test_dbname_dict_access(self):
-        """Dict-style access reads and writes dbname."""
-        original = dj.config.database.dbname
+    def test_database_name_dict_access(self):
+        """Dict-style access reads and writes database name."""
+        original = dj.config.database.name
         try:
-            dj.config.database.dbname = "test_db"
-            assert dj.config["database.dbname"] == "test_db"
+            dj.config.database.name = "test_db"
+            assert dj.config["database.name"] == "test_db"
         finally:
-            dj.config.database.dbname = original
-
-    def test_dbname_override_context_manager(self):
-        """Override context manager temporarily sets dbname."""
-        original = dj.config.database.dbname
-        with dj.config.override(database__dbname="override_db"):
-            assert dj.config.database.dbname == "override_db"
-        assert dj.config.database.dbname == original
+            dj.config.database.name = original
+
+    def test_database_name_override_context_manager(self):
+        """Override context manager temporarily sets database name."""
+        original = dj.config.database.name
+        with dj.config.override(database__name="override_db"):
+            assert dj.config.database.name == "override_db"
+        assert dj.config.database.name == original
+
+    def test_database_prefix_deprecation_warning(self, monkeypatch):
+        """Non-empty database_prefix emits DeprecationWarning."""
+        import warnings
+
+        from datajoint.settings import DatabaseSettings
+
+        monkeypatch.setenv("DJ_DATABASE_PREFIX", "test_")
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            DatabaseSettings()
+            deprecation_warnings = [
+                x for x in w if issubclass(x.category, DeprecationWarning) and "database_prefix" in str(x.message)
+            ]
+            assert len(deprecation_warnings) >= 1
+
+    def test_database_prefix_empty_no_warning(self):
+        """Empty database_prefix does not emit DeprecationWarning."""
+        import warnings
+
+        from datajoint.settings import DatabaseSettings
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            DatabaseSettings()
+            deprecation_warnings = [
+                x for x in w if issubclass(x.category, DeprecationWarning) and "database_prefix" in str(x.message)
+            ]
+            assert len(deprecation_warnings) == 0
 
 
 class TestBackendConfiguration: