Struct NormalizedSelect 

pub struct NormalizedSelect {
    pub table: String,
    pub columns: Vec<Expr>,
    pub joins: Vec<NormalizedJoin>,
    pub filters: Vec<FilterClause>,
    pub order_by: Vec<OrderByItem>,
    pub limit: Option<usize>,
    pub offset: Option<usize>,
}

Canonical representation for the rewrite-safe subset of SELECT.

Fields

table: String

columns: Vec<Expr>

joins: Vec<NormalizedJoin>

filters: Vec<FilterClause>

order_by: Vec<OrderByItem>

limit: Option<usize>

offset: Option<usize>

Implementations

impl NormalizedSelect

pub fn cleaned(&self) -> Self

Apply a deterministic cleanup rewrite that preserves the supported-subset semantics.

Cleanup rules:

• merge all AND filter clauses into one clause
• merge all OR filter clauses into one clause
• remove empty filter clauses
• sort and dedupe conditions in filter and join ON clauses
• dedupe repeated ORDER BY items while preserving the first occurrence

pub fn canonicalized(&self) -> Self

Return a canonicalized clone for structural comparison.

This only reorders semantically commutative components:

• condition order within a filter clause
• condition order within a join ON conjunction

It intentionally preserves the order of:

• projection columns
• joins
• filter clauses
• ORDER BY items

pub fn equivalent_shape(&self, other: &Self) -> bool

Compare two normalized queries under the supported-subset semantics.

pub fn to_qail(&self) -> Qail

Lower the normalized form back into a canonical QAIL SELECT.

Trait Implementations

impl Clone for NormalizedSelect

fn clone(&self) -> NormalizedSelect

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NormalizedSelect

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

Formats the value using the given formatter.

impl PartialEq for NormalizedSelect

fn eq(&self, other: &NormalizedSelect) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<&Qail> for NormalizedSelect

type Error = NormalizeError

The type returned in the event of a conversion error.

fn try_from(qail: &Qail) -> Result<Self, Self::Error>

Performs the conversion.

impl StructuralPartialEq for NormalizedSelect