Struct QueryExpr 

pub struct QueryExpr {
    pub source: SourceExpr,
    pub query: Vec<Query>,
}

Fields

source: SourceExpr

query: Vec<Query>

Implementations

impl QueryExpr

pub fn new<T: Into<SourceExpr>>(source: T) -> Self

pub fn walk_sources<E>( &self, on_source: &mut impl FnMut(&SourceExpr) -> Result<(), E>, ) -> Result<(), E>

Iterate over all SourceExprs involved in the QueryExpr.

Sources are yielded from left to right. Duplicates are not filtered out.

pub fn head(&self) -> &Arc<Header>

Returns the last Header of this query.

Starts the scan from the back to the front, looking for query operations that change the Header. These are JoinInner and Project. If there are no operations that alter the Header, this falls back to the origin self.source.head().

pub fn reads_from_table(&self, id: &TableId) -> bool

Does this query read from a given table?

pub fn with_index_eq( self, table: DbTable, columns: ColList, value: AlgebraicValue, ) -> Self

pub fn with_index_lower_bound( self, table: DbTable, columns: ColList, value: AlgebraicValue, inclusive: bool, ) -> Self

pub fn with_index_upper_bound( self, table: DbTable, columns: ColList, value: AlgebraicValue, inclusive: bool, ) -> Self

pub fn with_select<O>(self, op: O) -> Result<Self, RelationError>

where O: Into<FieldOp>,

pub fn with_select_cmp<LHS, RHS, O>( self, op: O, lhs: LHS, rhs: RHS, ) -> Result<Self, RelationError>

where LHS: Into<FieldExpr>, RHS: Into<FieldExpr>, O: Into<OpQuery>,

pub fn with_project( self, fields: Vec<FieldExpr>, wildcard_table: Option<TableId>, ) -> Result<Self, RelationError>

pub fn with_join_inner_raw( self, q_rhs: QueryExpr, c_lhs: ColId, c_rhs: ColId, inner: Option<Arc<Header>>, ) -> Self

pub fn with_join_inner( self, q_rhs: impl Into<QueryExpr>, c_lhs: ColId, c_rhs: ColId, semi: bool, ) -> Self

pub fn try_semi_join(self) -> QueryExpr

Try to turn an inner join followed by a projection into a semijoin.

This optimization recognizes queries of the form:

QueryExpr {
  source: LHS,
  query: [
    JoinInner(JoinExpr {
      rhs: RHS,
      semi: false,
      ..
    }),
    Project(LHS.*),
    ...
  ]
}

And combines the JoinInner with the Project into a JoinInner with semi: true.

Current limitations of this optimization:

• The JoinInner must be the first (0th) element of the query. Future work could search through the query to find any applicable JoinInners, but the current implementation inspects only the first expr. This is likely sufficient because this optimization is primarily useful for enabling try_index_join, which is fundamentally limited to operate on the first expr. Note that we still get to optimize incremental joins, because we first optimize the original query with DbTable sources, which results in an IndexJoin then we replace the sources with MemTables and go back to a [JoinInner] with semi: true.
• The Project must immediately follow the JoinInner, with no intervening exprs. Future work could search through intervening exprs to detect that the RHS table is unused.
• The LHS/source table must be a DbTable, not a MemTable. This is so we can recognize a wildcard project by its table id. Future work could inspect the set of projected fields and compare them to the LHS table’s header instead.

pub fn optimize(self, row_count: &impl Fn(TableId, &str) -> i64) -> Self

Trait Implementations

impl AuthAccess for QueryExpr

fn check_auth(&self, owner: Identity, caller: Identity) -> Result<(), AuthError>

impl Clone for QueryExpr

fn clone(&self) -> QueryExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QueryExpr

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

Formats the value using the given formatter.

impl From<IndexJoin> for QueryExpr

fn from(join: IndexJoin) -> Self

Converts to this type from the input type.

impl From<QueryExpr> for Expr

fn from(x: QueryExpr) -> Self

Converts to this type from the input type.

impl From<SourceExpr> for QueryExpr

fn from(source: SourceExpr) -> Self

Converts to this type from the input type.

impl Hash for QueryExpr

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for QueryExpr

fn eq(&self, other: &QueryExpr) -> 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 Eq for QueryExpr

impl StructuralPartialEq for QueryExpr