plain.models 0.33.1__py3-none-any.whl → 0.34.1__py3-none-any.whl

plain/models/sql/query.py

@@ -20,7 +20,7 @@ from string import ascii_uppercase
 from plain.exceptions import FieldDoesNotExist, FieldError
 from plain.models.aggregates import Count
 from plain.models.constants import LOOKUP_SEP
-from plain.models.db import DEFAULT_DB_ALIAS, NotSupportedError, connections
+from plain.models.db import NotSupportedError, db_connection
 from plain.models.expressions import (
     BaseExpression,
     Col,
@@ -83,10 +83,9 @@ JoinInfo = namedtuple(
 class RawQuery:
     """A single raw SQL query."""
 
-    def __init__(self, sql, using, params=()):
+    def __init__(self, sql, params=()):
         self.params = params
         self.sql = sql
-        self.using = using
         self.cursor = None
 
         # Mirror some properties of a normal query so that
@@ -95,23 +94,23 @@ class RawQuery:
         self.extra_select = {}
         self.annotation_select = {}
 
-    def chain(self, using):
-        return self.clone(using)
+    def chain(self):
+        return self.clone()
 
-    def clone(self, using):
-        return RawQuery(self.sql, using, params=self.params)
+    def clone(self):
+        return RawQuery(self.sql, params=self.params)
 
     def get_columns(self):
         if self.cursor is None:
             self._execute_query()
-        converter = connections[self.using].introspection.identifier_converter
+        converter = db_connection.introspection.identifier_converter
         return [converter(column_meta[0]) for column_meta in self.cursor.description]
 
     def __iter__(self):
         # Always execute a new query for a new iterator.
         # This could be optimized with a cache at the expense of RAM.
         self._execute_query()
-        if not connections[self.using].features.can_use_chunked_reads:
+        if not db_connection.features.can_use_chunked_reads:
             # If the database can't use chunked reads we need to make sure we
             # evaluate the entire query up front.
             result = list(self.cursor)
@@ -134,12 +133,10 @@ class RawQuery:
         return self.sql % self.params_type(self.params)
 
     def _execute_query(self):
-        connection = connections[self.using]
-
         # Adapt parameters to the database, as much as possible considering
         # that the target type isn't known. See #17755.
         params_type = self.params_type
-        adapter = connection.ops.adapt_unknown_value
+        adapter = db_connection.ops.adapt_unknown_value
         if params_type is tuple:
             params = tuple(adapter(val) for val in self.params)
         elif params_type is dict:
@@ -149,7 +146,7 @@ class RawQuery:
         else:
             raise RuntimeError(f"Unexpected params type: {params_type}")
 
-        self.cursor = connection.cursor()
+        self.cursor = db_connection.cursor()
         self.cursor.execute(self.sql, params)
 
 
@@ -286,7 +283,7 @@ class Query(BaseExpression):
         Return the query as an SQL string and the parameters that will be
         substituted into the query.
         """
-        return self.get_compiler(DEFAULT_DB_ALIAS).as_sql()
+        return self.get_compiler().as_sql()
 
     def __deepcopy__(self, memo):
         """Limit the amount of work when a Query is deepcopied."""
@@ -294,13 +291,9 @@ class Query(BaseExpression):
         memo[id(self)] = result
         return result
 
-    def get_compiler(self, using=None, connection=None, elide_empty=True):
-        if using is None and connection is None:
-            raise ValueError("Need either using or connection")
-        if using:
-            connection = connections[using]
-        return connection.ops.compiler(self.compiler)(
-            self, connection, using, elide_empty
+    def get_compiler(self, *, elide_empty=True):
+        return db_connection.ops.compiler(self.compiler)(
+            self, db_connection, elide_empty
         )
 
     def get_meta(self):
@@ -382,7 +375,7 @@ class Query(BaseExpression):
             alias = None
         return target.get_col(alias, field)
 
-    def get_aggregation(self, using, aggregate_exprs):
+    def get_aggregation(self, aggregate_exprs):
         """
         Return the dictionary with the values of the existing aggregations.
         """
@@ -519,7 +512,7 @@ class Query(BaseExpression):
         outer_query.clear_limits()
         outer_query.select_for_update = False
         outer_query.select_related = False
-        compiler = outer_query.get_compiler(using, elide_empty=elide_empty)
+        compiler = outer_query.get_compiler(elide_empty=elide_empty)
         result = compiler.execute_sql(SINGLE)
         if result is None:
             result = empty_set_result
@@ -529,12 +522,12 @@ class Query(BaseExpression):
 
         return dict(zip(outer_query.annotation_select, result))
 
-    def get_count(self, using):
+    def get_count(self):
         """
         Perform a COUNT() query using the current filter constraints.
         """
         obj = self.clone()
-        return obj.get_aggregation(using, {"__count": Count("*")})["__count"]
+        return obj.get_aggregation({"__count": Count("*")})["__count"]
 
     def has_filters(self):
         return self.where
@@ -561,12 +554,12 @@ class Query(BaseExpression):
         q.add_annotation(Value(1), "a")
         return q
 
-    def has_results(self, using):
-        q = self.exists(using)
-        compiler = q.get_compiler(using=using)
+    def has_results(self):
+        q = self.exists()
+        compiler = q.get_compiler()
         return compiler.has_results()
 
-    def explain(self, using, format=None, **options):
+    def explain(self, format=None, **options):
         q = self.clone()
         for option_name in options:
             if (
@@ -575,7 +568,7 @@ class Query(BaseExpression):
             ):
                 raise ValueError(f"Invalid option name: {option_name!r}.")
         q.explain_info = ExplainInfo(format, options)
-        compiler = q.get_compiler(using=using)
+        compiler = q.get_compiler()
         return "\n".join(compiler.explain_query())
 
     def combine(self, rhs, connector):
@@ -1110,12 +1103,12 @@ class Query(BaseExpression):
         # unnecessary ORDER BY clause.
         if (
             self.subquery
-            and not connection.features.ignores_unnecessary_order_by_in_subqueries
+            and not db_connection.features.ignores_unnecessary_order_by_in_subqueries
         ):
             self.clear_ordering(force=False)
             for query in self.combined_queries:
                 query.clear_ordering(force=False)
-        sql, params = self.get_compiler(connection=connection).as_sql()
+        sql, params = self.get_compiler().as_sql()
         if self.subquery:
             sql = f"({sql})"
         return sql, params
@@ -1241,13 +1234,12 @@ class Query(BaseExpression):
             return lhs.get_lookup("isnull")(lhs, True)
 
         # For Oracle '' is equivalent to null. The check must be done at this
-        # stage because join promotion can't be done in the compiler. Using
-        # DEFAULT_DB_ALIAS isn't nice but it's the best that can be done here.
-        # A similar thing is done in is_nullable(), too.
+        # stage because join promotion can't be done in the compiler. A similar
+        # thing is done in is_nullable(), too.
         if (
             lookup_name == "exact"
             and lookup.rhs == ""
-            and connections[DEFAULT_DB_ALIAS].features.interprets_empty_strings_as_nulls
+            and db_connection.features.interprets_empty_strings_as_nulls
         ):
             return lhs.get_lookup("isnull")(lhs, True)
 
@@ -2481,14 +2473,12 @@ class Query(BaseExpression):
         nullable for those backends. In such situations field.allow_null can be
         False even if we should treat the field as nullable.
         """
-        # We need to use DEFAULT_DB_ALIAS here, as QuerySet does not have
-        # (nor should it have) knowledge of which connection is going to be
-        # used. The proper fix would be to defer all decisions where
-        # is_nullable() is needed to the compiler stage, but that is not easy
-        # to do currently.
+        # QuerySet does not have knowledge of which connection is going to be
+        # used. For the single-database setup we always reference the default
+        # connection here.
         return field.allow_null or (
             field.empty_strings_allowed
-            and connections[DEFAULT_DB_ALIAS].features.interprets_empty_strings_as_nulls
+            and db_connection.features.interprets_empty_strings_as_nulls
         )
 
 

plain/models/sql/subqueries.py

@@ -14,16 +14,16 @@ class DeleteQuery(Query):
 
     compiler = "SQLDeleteCompiler"
 
-    def do_query(self, table, where, using):
+    def do_query(self, table, where):
         self.alias_map = {table: self.alias_map[table]}
         self.where = where
-        cursor = self.get_compiler(using).execute_sql(CURSOR)
+        cursor = self.get_compiler().execute_sql(CURSOR)
         if cursor:
             with cursor:
                 return cursor.rowcount
         return 0
 
-    def delete_batch(self, pk_list, using):
+    def delete_batch(self, pk_list):
         """
         Set up and execute delete queries for all the objects in pk_list.
 
@@ -39,9 +39,7 @@ class DeleteQuery(Query):
                 f"{field.attname}__in",
                 pk_list[offset : offset + GET_ITERATOR_CHUNK_SIZE],
             )
-            num_deleted += self.do_query(
-                self.get_meta().db_table, self.where, using=using
-            )
+            num_deleted += self.do_query(self.get_meta().db_table, self.where)
         return num_deleted
 
 
@@ -68,14 +66,14 @@ class UpdateQuery(Query):
         obj.related_updates = self.related_updates.copy()
         return obj
 
-    def update_batch(self, pk_list, values, using):
+    def update_batch(self, pk_list, values):
         self.add_update_values(values)
         for offset in range(0, len(pk_list), GET_ITERATOR_CHUNK_SIZE):
             self.clear_where()
             self.add_filter(
                 "pk__in", pk_list[offset : offset + GET_ITERATOR_CHUNK_SIZE]
             )
-            self.get_compiler(using).execute_sql(NO_RESULTS)
+            self.get_compiler().execute_sql(NO_RESULTS)
 
     def add_update_values(self, values):
         """

plain/models/sql/where.py

@@ -351,5 +351,5 @@ class SubqueryConstraint:
     def as_sql(self, compiler, connection):
         query = self.query_object
         query.set_values(self.targets)
-        query_compiler = query.get_compiler(connection=connection)
+        query_compiler = query.get_compiler()
         return query_compiler.as_subquery_condition(self.alias, self.columns, compiler)

plain/models/test/pytest.py

@@ -6,10 +6,10 @@ from plain.signals import request_finished, request_started
 
 from .. import transaction
 from ..backends.base.base import BaseDatabaseWrapper
-from ..db import close_old_connections, connections
+from ..db import close_old_connections, db_connection
 from .utils import (
-    setup_databases,
-    teardown_databases,
+    setup_database,
+    teardown_database,
 )
 
 
@@ -40,7 +40,7 @@ def setup_db(request):
     verbosity = request.config.option.verbose
 
     # Set up the test db across the entire session
-    _old_db_config = setup_databases(verbosity=verbosity)
+    _old_db_name = setup_database(verbosity=verbosity)
 
     # Keep connections open during request client / testing
     request_started.disconnect(close_old_connections)
@@ -53,7 +53,7 @@ def setup_db(request):
     request_finished.connect(close_old_connections)
 
     # When the test session is done, tear down the test db
-    teardown_databases(_old_db_config, verbosity=verbosity)
+    teardown_database(_old_db_name, verbosity=verbosity)
 
 
 @pytest.fixture
@@ -63,37 +63,26 @@ def db(setup_db, request):
     # Set .cursor() back to the original implementation to unblock it
     BaseDatabaseWrapper.cursor = BaseDatabaseWrapper._enabled_cursor
 
-    # Keep track of the atomic blocks so we can roll them back
-    atomics = {}
+    if not db_connection.features.supports_transactions:
+        pytest.fail("Database does not support transactions")
 
-    for connection in connections.all():
-        # By default we use transactions to rollback changes,
-        # so we need to ensure the database supports transactions
-        if not connection.features.supports_transactions:
-            pytest.fail("Database does not support transactions")
-
-        # Clear the queries log before each test?
-        # connection.queries_log.clear()
-
-        atomic = transaction.atomic(using=connection.alias)
-        atomic._from_testcase = True  # TODO remove this somehow?
-        atomic.__enter__()
-        atomics[connection] = atomic
+    atomic = transaction.atomic()
+    atomic._from_testcase = True  # TODO remove this somehow?
+    atomic.__enter__()
 
     yield
 
-    for connection, atomic in atomics.items():
-        if (
-            connection.features.can_defer_constraint_checks
-            and not connection.needs_rollback
-            and connection.is_usable()
-        ):
-            connection.check_constraints()
+    if (
+        db_connection.features.can_defer_constraint_checks
+        and not db_connection.needs_rollback
+        and db_connection.is_usable()
+    ):
+        db_connection.check_constraints()
 
-        transaction.set_rollback(True, using=connection.alias)
-        atomic.__exit__(None, None, None)
+    db_connection.set_rollback(True)
+    atomic.__exit__(None, None, None)
 
-        connection.close()
+    db_connection.close()
 
 
 @pytest.fixture
@@ -115,9 +104,9 @@ def isolated_db(request):
     prefix = re.sub(r"[^0-9A-Za-z_]+", "_", raw_name)
 
     # Set up a fresh test database for this test, using the prefix
-    _old_db_config = setup_databases(verbosity=verbosity, prefix=prefix)
+    _old_db_name = setup_database(verbosity=verbosity, prefix=prefix)
 
     yield
 
     # Tear down the test database created for this test
-    teardown_databases(_old_db_config, verbosity=verbosity)
+    teardown_database(_old_db_name, verbosity=verbosity)

plain/models/test/utils.py

@@ -1,147 +1,11 @@
-from plain.exceptions import ImproperlyConfigured
-from plain.models import DEFAULT_DB_ALIAS, connections
+from plain.models import db_connection
 
 
-def setup_databases(*, verbosity, prefix=""):
-    """
-    Create the test databases.
+def setup_database(*, verbosity, prefix=""):
+    old_name = db_connection.settings_dict["NAME"]
+    db_connection.creation.create_test_db(verbosity=verbosity, prefix=prefix)
+    return old_name
 
-    If prefix is provided, each test database name will be prefixed with
-    "<prefix>_" to isolate it from the default test database.
-    """
 
-    test_databases, mirrored_aliases = get_unique_databases_and_mirrors(prefix=prefix)
-
-    old_names = []
-
-    for db_name, aliases in test_databases.values():
-        first_alias = None
-        for alias in aliases:
-            connection = connections[alias]
-            old_names.append((connection, db_name, first_alias is None))
-
-            # Actually create the database for the first connection
-            if first_alias is None:
-                first_alias = alias
-                connection.creation.create_test_db(
-                    verbosity=verbosity,
-                    prefix=prefix,
-                )
-            # Configure all other connections as mirrors of the first one
-            else:
-                connections[alias].creation.set_as_test_mirror(
-                    connections[first_alias].settings_dict
-                )
-
-    # Configure the test mirrors.
-    for alias, mirror_alias in mirrored_aliases.items():
-        connections[alias].creation.set_as_test_mirror(
-            connections[mirror_alias].settings_dict
-        )
-
-    return old_names
-
-
-def get_unique_databases_and_mirrors(prefix=""):
-    """
-    Figure out which databases actually need to be created.
-
-    Deduplicate entries in DATABASES that correspond the same database or are
-    configured as test mirrors.
-
-    Return two values:
-    - test_databases: ordered mapping of signatures to (name, list of aliases)
-                      where all aliases share the same underlying database.
-    - mirrored_aliases: mapping of mirror aliases to original aliases.
-    """
-
-    aliases = connections
-    mirrored_aliases = {}
-    test_databases = {}
-    dependencies = {}
-    default_sig = connections[DEFAULT_DB_ALIAS].creation.test_db_signature(prefix)
-
-    for alias in connections:
-        connection = connections[alias]
-        test_settings = connection.settings_dict["TEST"]
-
-        if test_settings["MIRROR"]:
-            # If the database is marked as a test mirror, save the alias.
-            mirrored_aliases[alias] = test_settings["MIRROR"]
-        elif alias in aliases:
-            # Store a tuple with DB parameters that uniquely identify it.
-            # If we have two aliases with the same values for that tuple,
-            # we only need to create the test database once.
-            item = test_databases.setdefault(
-                connection.creation.test_db_signature(prefix),
-                (connection.settings_dict["NAME"], []),
-            )
-            # The default database must be the first because data migrations
-            # use the default alias by default.
-            if alias == DEFAULT_DB_ALIAS:
-                item[1].insert(0, alias)
-            else:
-                item[1].append(alias)
-
-            if "DEPENDENCIES" in test_settings:
-                dependencies[alias] = test_settings["DEPENDENCIES"]
-            else:
-                if (
-                    alias != DEFAULT_DB_ALIAS
-                    and connection.creation.test_db_signature(prefix) != default_sig
-                ):
-                    dependencies[alias] = test_settings.get(
-                        "DEPENDENCIES", [DEFAULT_DB_ALIAS]
-                    )
-
-    test_databases = dict(dependency_ordered(test_databases.items(), dependencies))
-    return test_databases, mirrored_aliases
-
-
-def teardown_databases(old_config, verbosity):
-    """Destroy all the non-mirror databases."""
-    for connection, old_name, destroy in old_config:
-        if destroy:
-            connection.creation.destroy_test_db(old_name, verbosity)
-
-
-def dependency_ordered(test_databases, dependencies):
-    """
-    Reorder test_databases into an order that honors the dependencies
-    described in TEST[DEPENDENCIES].
-    """
-    ordered_test_databases = []
-    resolved_databases = set()
-
-    # Maps db signature to dependencies of all its aliases
-    dependencies_map = {}
-
-    # Check that no database depends on its own alias
-    for sig, (_, aliases) in test_databases:
-        all_deps = set()
-        for alias in aliases:
-            all_deps.update(dependencies.get(alias, []))
-        if not all_deps.isdisjoint(aliases):
-            raise ImproperlyConfigured(
-                f"Circular dependency: databases {aliases!r} depend on each other, "
-                "but are aliases."
-            )
-        dependencies_map[sig] = all_deps
-
-    while test_databases:
-        changed = False
-        deferred = []
-
-        # Try to find a DB that has all its dependencies met
-        for signature, (db_name, aliases) in test_databases:
-            if dependencies_map[signature].issubset(resolved_databases):
-                resolved_databases.update(aliases)
-                ordered_test_databases.append((signature, (db_name, aliases)))
-                changed = True
-            else:
-                deferred.append((signature, (db_name, aliases)))
-
-        if not changed:
-            raise ImproperlyConfigured("Circular dependency in TEST[DEPENDENCIES]")
-        test_databases = deferred
-    return ordered_test_databases
+def teardown_database(old_name, verbosity):
+    db_connection.creation.destroy_test_db(old_name, verbosity)