pub struct Pushdown {Show 15 fields
pub sql: String,
pub sums: Vec<FloatSum>,
pub order_table: Option<String>,
pub join_left: Option<(String, Vec<String>)>,
pub order_then: Option<String>,
pub order_then_as: Option<String>,
pub order_first: Option<String>,
pub order_desc: bool,
pub order_groups: bool,
pub limit: Option<u64>,
pub record: bool,
pub properties: bool,
pub keyed_by: Option<(Refusal, String)>,
pub column_types: ColumnTypes,
pub tables: Vec<String>,
}Fields§
§sql: String§sums: Vec<FloatSum>The plan’s sums and means over a column, for a source that
adds floats in its own order: see FloatSum. Empty for a
plan that joins.
order_table: Option<String>§join_left: Option<(String, Vec<String>)>Present when the plan contains a witness JOIN: the joined table and the columns its ON equalities bind on it (collected structurally from the arbor, so query text cannot spoof them). The plan is only sound if those columns form a unique key of the joined table — each FROM row must find at most one witness, else SQL multiplies rows where Quarb’s existential binding does not. The driver must verify against its catalog before executing, and fall back to the scan if it cannot.
order_then: Option<String>Present when the plan is an every-witness JOIN (<=>*,
ruling 2026-11-11): the joined table. Such a JOIN is what the
query asks, so it carries no uniqueness obligation
(join_left is absent); its obligation is the ORDER: the
rows of one driver stand in the joined table’s own order,
after the driver’s (order_table’s key, then this table’s).
A driver that cannot order by both must decline the plan.
order_then_as: Option<String>The name that second table bears in the statement where it is not its own: a table joined to itself is aliased, and the driver writes its key under the alias.
order_first: Option<String>The plan’s own sort, in SQL, where it has one: (n IS NULL), n for sort_by(::n), a null key last as the engine puts it.
The driver writes it before the keys, which keep the ties in
the tables’ order as the engine’s stable sort does.
order_desc: boolThe keys descending: the context reversed (@| reverse).
order_groups: boolThe plan is a fold: one row a group, in the order each group
first appears, which the driver writes as the least key of
each (ORDER BY MIN(key)).
limit: Option<u64>The first rows alone (@| [..n]), after the order.
record: boolThe plan’s rows are records the query built (| %(…), the
%. of a fold): a row of one column is then a record of one
field, where a projection’s is the bare value.
properties: boolThe plan’s rows are the records of the rows’ own properties
(| %): a NULL cell is no property of its row, and is left
out of that row’s record, as the scan leaves it out.
keyed_by: Option<(Refusal, String)>The column a sort, a fold or a distinct count goes by, with
the word of that construct. The plan is the scan’s only where
the catalog says the column is numeric (it is among
column_types.numeric), and unlike a comparison the database
would not refuse it over a text column: it would run, and
answer its collation’s order or its own groups. A caller with
no catalog to ask scans; one whose catalog says the column is
not numeric scans and tells of it under the word.
column_types: ColumnTypesWhat the plan takes for granted about column types. Quarb compares by value (a numeric-looking text and a number meet as numbers, a number and other text never meet); SQL compares by the column’s type, and the loosely typed engines (SQLite, MySQL) coerce by rules of their own. The plan is the scan’s only where the columns it compares with a number are numeric-typed and those it compares with text are not: the caller asks its catalog and scans when one is otherwise. (A strictly typed engine rejects the mismatch itself, which sends the caller to the scan as well.)
tables: Vec<String>The tables the plan reads (the FROM table, then a joined one).