Single DATABASE instead of DATABASES and DATABASE_ROUTERS (#47)

Author: davegaeddert

demos/full/app/settings.py

@@ -28,11 +28,9 @@
 SUPPORT_EMAIL = "support@example.com"
 OAUTH_LOGIN_PROVIDERS = {}
 
-DATABASES = {
-    "default": {
-        "ENGINE": "plain.models.backends.sqlite3",
-        "NAME": ":memory:",
-    }
+DATABASE = {
+    "ENGINE": "plain.models.backends.sqlite3",
+    "NAME": ":memory:",
 }
 
 MIDDLEWARE = [

plain-admin/plain/admin/querystats/middleware.py

@@ -3,7 +3,7 @@
 import re
 
 from plain.json import PlainJSONEncoder
-from plain.models import DEFAULT_DB_ALIAS, connections
+from plain.models import db_connection
 from plain.runtime import settings
 
 from .core import QueryStats
@@ -59,11 +59,11 @@ def is_tracking():
 
         querystats = QueryStats(include_tracebacks=is_tracking())
 
-        with connections[DEFAULT_DB_ALIAS].execute_wrapper(querystats):
+        with db_connection.execute_wrapper(querystats):
             is_admin = self.is_admin_request(request)
 
         if settings.DEBUG or is_admin:
-            with connections[DEFAULT_DB_ALIAS].execute_wrapper(querystats):
+            with db_connection.execute_wrapper(querystats):
                 response = self.get_response(request)
 
             if settings.DEBUG:

plain-admin/tests/app/settings.py

@@ -9,11 +9,9 @@
     "plain.admin",
     "app.users",
 ]
-DATABASES = {
-    "default": {
-        "ENGINE": "plain.models.backends.sqlite3",
-        "NAME": ":memory:",
-    }
+DATABASE = {
+    "ENGINE": "plain.models.backends.sqlite3",
+    "NAME": ":memory:",
 }
 MIDDLEWARE = [
     "plain.sessions.middleware.SessionMiddleware",

plain-flags/plain/flags/admin.py

@@ -18,7 +18,7 @@ class UnusedFlagsCard(Card):
 
     @cached_property
     def flag_errors(self):
-        return Flag.check(databases=["default"])
+        return Flag.check(database=True)
 
     def get_number(self):
         return len(self.flag_errors)

plain-flags/plain/flags/models.py

@@ -79,33 +79,30 @@ def check(cls, **kwargs):
         """
         errors = super().check(**kwargs)
 
-        databases = kwargs["databases"]
-        if not databases:
+        database = kwargs.get("database", False)
+        if not database:
             return errors
 
-        for database in databases:
-            flag_names = (
-                cls.objects.using(database).all().values_list("name", flat=True)
-            )
+        flag_names = cls.objects.all().values_list("name", flat=True)
 
+        try:
+            flag_names = set(flag_names)
+        except ProgrammingError:
+            # The table doesn't exist yet
+            # (migrations probably haven't run yet),
+            # so we can't check it.
+            return errors
+
+        for flag_name in flag_names:
             try:
-                flag_names = set(flag_names)
-            except ProgrammingError:
-                # The table doesn't exist yet
-                # (migrations probably haven't run yet),
-                # so we can't check it.
-                continue
-
-            for flag_name in flag_names:
-                try:
-                    get_flag_class(flag_name)
-                except FlagImportError:
-                    errors.append(
-                        Info(
-                            f"Flag {flag_name} is not used.",
-                            hint=f"Remove the flag from the database or define it in the {settings.FLAGS_MODULE} module.",
-                            id="plain.flags.I001",
-                        )
+                get_flag_class(flag_name)
+            except FlagImportError:
+                errors.append(
+                    Info(
+                        f"Flag {flag_name} is not used.",
+                        hint=f"Remove the flag from the database or define it in the {settings.FLAGS_MODULE} module.",
+                        id="plain.flags.I001",
                     )
+                )
 
         return errors

plain-flags/tests/app/settings.py

@@ -4,9 +4,7 @@
     "plain.models",
     "plain.flags",
 ]
-DATABASES = {
-    "default": {
-        "ENGINE": "plain.models.backends.sqlite3",
-        "NAME": ":memory:",
-    }
+DATABASE = {
+    "ENGINE": "plain.models.backends.sqlite3",
+    "NAME": ":memory:",
 }

plain-models/plain/models/README.md

@@ -60,19 +60,17 @@ To connect to a database, you can provide a `DATABASE_URL` environment variable.
 DATABASE_URL=postgresql://user:password@localhost:5432/dbname
 ```
 
-Or you can manually define the `DATABASES` setting.
+Or you can manually define the `DATABASE` setting.
 
 ```python
 # app/settings.py
-DATABASES = {
-    "default": {
-        "ENGINE": "plain.models.backends.postgresql",
-        "NAME": "dbname",
-        "USER": "user",
-        "PASSWORD": "password",
-        "HOST": "localhost",
-        "PORT": "5432",
-    }
+DATABASE = {
+    "ENGINE": "plain.models.backends.postgresql",
+    "NAME": "dbname",
+    "USER": "user",
+    "PASSWORD": "password",
+    "HOST": "localhost",
+    "PORT": "5432",
 }
 ```
 

plain-models/plain/models/__init__.py

@@ -8,7 +8,6 @@
 from .constraints import *  # NOQA
 from .constraints import __all__ as constraints_all
 from .db import (
-    DEFAULT_DB_ALIAS,
     PLAIN_VERSION_PICKLE_KEY,
     DatabaseError,
     DataError,
@@ -20,9 +19,8 @@
     OperationalError,
     ProgrammingError,
     close_old_connections,
-    connections,
+    db_connection,
     reset_queries,
-    router,
 )
 from .deletion import (
     CASCADE,
@@ -127,8 +125,7 @@
 
 # DB-related exports
 __all__ += [
-    "connections",
-    "router",
+    "db_connection",
     "reset_queries",
     "close_old_connections",
     "DatabaseError",
@@ -140,7 +137,6 @@
     "Error",
     "InterfaceError",
     "OperationalError",
-    "DEFAULT_DB_ALIAS",
     "PLAIN_VERSION_PICKLE_KEY",
 ]
 

plain-models/plain/models/backends/base/base.py

@@ -14,16 +14,14 @@
 from plain.models.backends.base.validation import BaseDatabaseValidation
 from plain.models.backends.utils import debug_transaction
 from plain.models.db import (
-    DEFAULT_DB_ALIAS,
     DatabaseError,
     DatabaseErrorWrapper,
     NotSupportedError,
 )
 from plain.models.transaction import TransactionManagementError
 from plain.runtime import settings
 
-NO_DB_ALIAS = "__no_db__"
-RAN_DB_VERSION_CHECK = set()
+RAN_DB_VERSION_CHECK = False
 
 logger = logging.getLogger("plain.models.backends.base")
 
@@ -51,15 +49,14 @@ class BaseDatabaseWrapper:
 
     queries_limit = 9000
 
-    def __init__(self, settings_dict, alias=DEFAULT_DB_ALIAS):
+    def __init__(self, settings_dict):
         # Connection related attributes.
         # The underlying database connection.
         self.connection = None
         # `settings_dict` should be a dictionary containing keys such as
         # NAME, USER, etc. It's called `settings_dict` instead of `settings`
         # to disambiguate it from Plain settings modules.
         self.settings_dict = settings_dict
-        self.alias = alias
         # Query logging in debug mode or when explicitly enabled.
         self.queries_log = deque(maxlen=self.queries_limit)
         self.force_debug_cursor = False
@@ -120,10 +117,7 @@ def __init__(self, settings_dict, alias=DEFAULT_DB_ALIAS):
         self.validation = self.validation_class(self)
 
     def __repr__(self):
-        return (
-            f"<{self.__class__.__qualname__} "
-            f"vendor={self.vendor!r} alias={self.alias!r}>"
-        )
+        return f"<{self.__class__.__qualname__} vendor={self.vendor!r}>"
 
     def ensure_timezone(self):
         """
@@ -218,9 +212,9 @@ def get_new_connection(self, conn_params):
     def init_connection_state(self):
         """Initialize the database connection settings."""
         global RAN_DB_VERSION_CHECK
-        if self.alias not in RAN_DB_VERSION_CHECK:
+        if not RAN_DB_VERSION_CHECK:
             self.check_database_version_supported()
-            RAN_DB_VERSION_CHECK.add(self.alias)
+            RAN_DB_VERSION_CHECK = True
 
     def create_cursor(self, name=None):
         """Create a cursor. Assume that a connection is established."""
@@ -593,8 +587,8 @@ def validate_thread_sharing(self):
         if not (self.allow_thread_sharing or self._thread_ident == _thread.get_ident()):
             raise DatabaseError(
                 "DatabaseWrapper objects created in a "
-                "thread can only be used in that same thread. The object "
-                f"with alias '{self.alias}' was created in thread id {self._thread_ident} and this is "
+                "thread can only be used in that same thread. The connection "
+                f"was created in thread id {self._thread_ident} and this is "
                 f"thread id {_thread.get_ident()}."
             )
 
@@ -656,7 +650,7 @@ def _nodb_cursor(self):
         being exposed to potential child threads while (or after) the test
         database is destroyed. Refs #10868, #17786, #16969.
         """
-        conn = self.__class__({**self.settings_dict, "NAME": None}, alias=NO_DB_ALIAS)
+        conn = self.__class__({**self.settings_dict, "NAME": None})
         try:
             with conn.cursor() as cursor:
                 yield cursor
@@ -729,13 +723,11 @@ def execute_wrapper(self, wrapper):
         finally:
             self.execute_wrappers.pop()
 
-    def copy(self, alias=None):
+    def copy(self):
         """
         Return a copy of this connection.
 
         For tests that require two connections to the same database.
         """
         settings_dict = copy.deepcopy(self.settings_dict)
-        if alias is None:
-            alias = self.alias
-        return type(self)(settings_dict, alias)
+        return type(self)(settings_dict)

plain-models/plain/models/backends/base/creation.py

@@ -45,7 +45,7 @@ def create_test_db(self, verbosity=1, prefix=""):
         )
 
         self.connection.close()
-        settings.DATABASES[self.connection.alias]["NAME"] = test_database_name
+        settings.DATABASE["NAME"] = test_database_name
         self.connection.settings_dict["NAME"] = test_database_name
 
         # We report migrate messages at one level lower than that
@@ -54,7 +54,6 @@ def create_test_db(self, verbosity=1, prefix=""):
         migrate.callback(
             package_label=None,
             migration_name=None,
-            database=self.connection.alias,
             fake=False,
             fake_initial=False,
             plan=False,
@@ -219,7 +218,7 @@ def destroy_test_db(self, old_database_name=None, verbosity=1):
 
         # Restore the original database name
         if old_database_name is not None:
-            settings.DATABASES[self.connection.alias]["NAME"] = old_database_name
+            settings.DATABASE["NAME"] = old_database_name
             self.connection.settings_dict["NAME"] = old_database_name
 
     def _destroy_test_db(self, test_database_name, verbosity):
@@ -244,7 +243,7 @@ def sql_table_creation_suffix(self):
     def test_db_signature(self, prefix=""):
         """
         Return a tuple with elements of self.connection.settings_dict (a
-        DATABASES setting value) that uniquely identify a database
+        DATABASE setting value) that uniquely identify a database
         accordingly to the RDBMS particularities.
         """
         settings_dict = self.connection.settings_dict