Struct TableChain 

pub struct TableChain<S> { /* private fields */ }

A table-or-subquery — or a qualified-table-name — under construction.

[ schema. ] table-name [ AS alias ] [ INDEXED BY index-name | NOT INDEXED ]
[ schema. ] table-function ( expr [, ...] ) [ AS alias ]
( select-stmt ) [ AS alias ]

That is the whole list of decorations SQLite allows on a from-item, and it is shorter than PostgreSQL’s by everything: no ONLY, no LATERAL, no WITH ORDINALITY, no TABLESAMPLE, and no column-alias list — t (a, b) is PostgreSQL’s, and SQLite has only AS alias. A table-valued function needs no mod of its own either, because a call is already an expression: from(f("pragma_table_info", s("users"))).

Implementations

impl<S> TableChain<S>

pub fn as_(self, alias: impl Into<Cow<'static, str>>) -> TableChain<S>

AS "alias".

pub fn indexed_by(self, name: impl Into<Cow<'static, str>>) -> TableChain<S>

INDEXED BY "name" — refuse to plan this item any other way.

A tuning hint that SQLite treats as a hard constraint: it is an error if the named index cannot be used. Applies to a table name, not to a sub-query or a table-valued function.

pub fn not_indexed(self) -> TableChain<S>

NOT INDEXED — plan this item without any index the planner would otherwise have chosen.

impl TableChain<ExtraSlot>

pub fn join(self, join: impl Into<Join>) -> TableChain<ExtraSlot>

A join written after this comma-separated item rather than after the leading one: FROM "a", "b" INNER JOIN "c" ON ….

Grammatical because the comma is one of SQLite’s join operators: parse.y reads the whole FROM as one chain — seltablist ::= stl_prefix nm …, stl_prefix ::= seltablist joinop, and joinop ::= COMMA|JOIN — so a JOIN may follow a comma item. One honest caveat, and it is SQLite’s, not this method’s: the operators are processed left to right with no precedence, so the join’s left operand is everything before it in the list, not this item alone — unlike PostgreSQL and MySQL, where the join binds tighter than the comma. Takes the same JoinChain the standalone join mods are — those reach the leading item through HasJoins, which is why the extra items take theirs by method instead. Several calls chain several joins.

Trait Implementations

impl<S: Clone> Clone for TableChain<S>

fn clone(&self) -> TableChain<S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Debug> Debug for TableChain<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Q, S: TableSlot<Q>> Mod<Q> for TableChain<S>

fn apply(self, q: &mut Q)

Apply this modification to q.