Struct Subquery 

pub struct Subquery<T: Model, V> { /* private fields */ }

Typed scalar subquery — lowers to (SELECT <col> FROM <table> WHERE <cond>) when emitted. T pins the source model (so the emitter knows which table to SELECT from) and V pins the column’s Rust type (so the scalar returned by the subquery slots into Expr<V> positions without an explicit cast). Both are phantom-typed; the node itself carries only the untyped [SubqueryNode] payload. #[must_use] — a dropped Subquery is usually a mistake; the user likely meant to feed it to .as_expr() and thence to crate::query::QuerySet::filter_expr / an arithmetic composition. Construction: Subquery::new takes the source queryset and the projected column. No other public constructor — the SubqueryNode inside is crate-private so downstream code cannot fabricate a subquery with a mismatched column / type pair.

Implementations

impl<T: Model, V> Subquery<T, V>

pub fn new<S>(qs: QuerySet<T>, column: S) -> Self

where S: IntoSqlField<T, V>,

Build a scalar subquery from a source queryset and the column to project. The qs parameter supplies the FROM <table> source and the correlated WHERE predicate; the column parameter picks which scalar the subquery returns. T on both arguments is the same model, so the compiler rejects a column ref taken from a different model’s Fields handle.

How the WHERE clause flows

qs.condition is cloned verbatim into the [SubqueryNode::where_clause] slot — every lookup op the caller composed via filter / filter_expr is preserved. The clone is structural (the condition tree is shallow Vec / Box / enum variants); typical correlated-subquery call sites build the queryset fresh, so there is nothing to share-ownership with. Condition::True (the “no filter” identity) is stored as Some(True) and the emitter renders it as WHERE TRUE. This matches the existing push_where shim’s behaviour — a vacuous predicate is rare in correlated subqueries, so the emission overhead is not worth a special case here.

What this ignores about qs

A queryset carries ordering, limit/offset, distinct mode, and prefetch / select_related registrations. The subquery emitter consumes only the table name and condition tree; ordering and pagination are ignored because Postgres’ scalar-subquery context does not use them (a scalar subquery must return a single value; ORDER BY ... LIMIT 1 would be the usual way to force that but is out of scope for Task 5). Callers who need a deterministic scalar from a multi-row source should use ctx.raw_scalar until extends this surface. PR3: accepts both legacy FieldRef<T, V> and the post-flip root accessor return type DjogiField<T, V> through the sealed IntoSqlField bridge. Subquery SELECT <col> is a SQL-only emission boundary — the projected column metadata flows through unchanged.

pub fn as_expr(self) -> Expr<V>

Promote this subquery to a typed Expr<V> for use in filter_expr, set_expr, or any other expression-IR consumer. The phantom V on Subquery<T, V> projects directly onto the resulting Expr<V> — so a subquery that selects a HeerId column produces an Expr<HeerId> that can .eq another Expr<HeerId>, and nothing else. Type discipline all the way through.