Skip to main content

Pushdown

Struct Pushdown 

Source
pub struct Pushdown {
Show 13 fields pub sql: String, pub order_table: Option<String>, pub join_left: Option<(String, Vec<String>)>, pub order_then: 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>,
}
Expand description

A pushdown plan: SQL whose execution is provably identical to the Quarb query’s — plus the table whose primary key must order the rows (None for a single aggregate row, where order is moot). The driver appends the ORDER BY, since the key lives in its catalog.

Fields§

§sql: String§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_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: bool

The keys descending: the context reversed (@| reverse).

§order_groups: bool

The 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: bool

The 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: bool

The 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: ColumnTypes

What 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).

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> ErasedDestructor for T
where T: 'static,

Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = !

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, !>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.