Remove SubqueryConstraint and other multi-column FK orphans

Follow-up cleanup after removing MultiColSource. All of these only existed
to support multi-column FK joins which aren't possible in plain-postgres:

- SubqueryConstraint (sql/where.py) — only instantiated by the deleted
  MultiColSource branch in RelatedIn.as_sql
- SQLCompiler.as_subquery_condition — only caller was SubqueryConstraint
- Unreachable `len(targets) > 1` FieldError raise in build_filter's F()
  handling (sql/query.py)
- Unreachable `len(target_fields) > 1` FieldError raise in
  ForeignObjectRel.target_field (reverse_related.py)

Author: davegaeddert

plain-postgres/plain/postgres/fields/reverse_related.py

@@ -14,7 +14,6 @@
 from functools import cached_property
 from typing import TYPE_CHECKING, Any
 
-from plain.postgres.exceptions import FieldError
 from plain.utils.hashable import make_hashable
 
 from . import BLANK_CHOICE_DASH
@@ -94,10 +93,7 @@ def target_field(self) -> Field:
         When filtering against this relation, return the field on the remote
         model against which the filtering should happen.
         """
-        target_fields = self.path_infos[-1].target_fields
-        if len(target_fields) > 1:
-            raise FieldError("Can't use target_field for multicolumn relations.")
-        return target_fields[0]
+        return self.path_infos[-1].target_fields[0]
 
     @cached_property
     def related_model(self) -> type[Model]:

plain-postgres/plain/postgres/sql/compiler.py

@@ -43,7 +43,6 @@
     SINGLE,
 )
 from plain.postgres.sql.query import Query, get_order_dir
-from plain.postgres.sql.where import AND
 from plain.postgres.transaction import TransactionManagementError
 from plain.utils.hashable import make_hashable
 from plain.utils.regex_helper import _lazy_re_compile
@@ -1426,20 +1425,6 @@ def execute_sql(
             rows = [r[: self.col_count] for r in rows]
         return rows
 
-    def as_subquery_condition(
-        self, alias: str, columns: list[str], compiler: SQLCompiler
-    ) -> SqlWithParams:
-        qn = compiler.quote_name_unless_alias
-        qn2 = quote_name
-
-        for index, select_col in enumerate(self.query.select):
-            lhs_sql, lhs_params = self.compile(select_col)
-            rhs = f"{qn(alias)}.{qn2(columns[index])}"
-            self.query.where.add(RawSQL(f"{lhs_sql} = {rhs}", lhs_params), AND)
-
-        sql, params = self.as_sql()
-        return f"EXISTS ({sql})", params
-
     def explain_query(self) -> Generator[str]:
         result = self.execute_sql()
         explain_info = self.query.explain_info

plain-postgres/plain/postgres/sql/query.py

@@ -1996,10 +1996,6 @@ def resolve_ref(
                 raise FieldError(
                     "Joined field references are not permitted in this query"
                 )
-            if len(targets) > 1:
-                raise FieldError(
-                    "Referencing multicolumn fields with F() objects isn't supported"
-                )
             # Verify that the last lookup in name is a field or a transform:
             # transform_function() raises FieldError if not.
             transform = join_info.transform_function(targets[0], final_alias)

plain-postgres/plain/postgres/sql/where.py

@@ -348,27 +348,3 @@ def as_sql(
     ) -> tuple[str, list[Any]]:
         sqls = [f"({sql})" for sql in self.sqls]
         return " AND ".join(sqls), list(self.params or ())
-
-
-class SubqueryConstraint:
-    # Even if aggregates or windows would be used in a subquery,
-    # the outer query isn't interested about those.
-    contains_aggregate = False
-    contains_over_clause = False
-
-    def __init__(
-        self, alias: str, columns: list[str], targets: list[Any], query_object: Any
-    ):
-        self.alias = alias
-        self.columns = columns
-        self.targets = targets
-        query_object.clear_ordering(clear_default=True)
-        self.query_object = query_object
-
-    def as_sql(
-        self, compiler: SQLCompiler, connection: DatabaseConnection
-    ) -> tuple[str, list[Any]]:
-        query = self.query_object
-        query.set_values(self.targets)
-        query_compiler = query.get_compiler()
-        return query_compiler.as_subquery_condition(self.alias, self.columns, compiler)