Trait AsQuery

pub trait AsQuery {
    type SqlType;
    type Query: Query<SqlType = Self::SqlType>;

    // Required method
    fn as_query(self) -> Self::Query;
}

Types that can be converted into a complete, typed SQL query.

This is used internally to automatically add the right select clause when none is specified, or to automatically add RETURNING * in certain contexts.

A type which implements this trait is guaranteed to be valid for execution.

Required Associated Types

type SqlType

The SQL type of Self::Query

type Query: Query<SqlType = Self::SqlType>

What kind of query does this type represent?

Required Methods

fn as_query(self) -> Self::Query

Converts a type which semantically represents a SQL query into the actual query being executed. See the trait level docs for more.

Implementors

impl<S> AsQuery for Alias<S>

where S: AliasSource, S::Target: AsQuery, Self: QuerySource, <Self as QuerySource>::DefaultSelection: ValidGrouping<()>,

type SqlType = <<Alias<S> as QuerySource>::DefaultSelection as Expression>::SqlType

type Query = SelectStatement<FromClause<Alias<S>>>

impl<S> AsQuery for Only<S>

where S: Table + Clone, <S as QuerySource>::DefaultSelection: ValidGrouping<()> + SelectableExpression<Only<S>>,

type SqlType = <<Only<S> as QuerySource>::DefaultSelection as Expression>::SqlType

type Query = SelectStatement<FromClause<Only<S>>>

impl<S, TSM> AsQuery for Tablesample<S, TSM>

where S: Table + Clone, TSM: TablesampleMethod, <S as QuerySource>::DefaultSelection: ValidGrouping<()> + SelectableExpression<Tablesample<S, TSM>>,

type SqlType = <<Tablesample<S, TSM> as QuerySource>::DefaultSelection as Expression>::SqlType

type Query = SelectStatement<FromClause<Tablesample<S, TSM>>>

impl<T, U> AsQuery for DeleteStatement<T, U, NoReturningClause>

where T: Table, T::AllColumns: SelectableExpression<T>, DeleteStatement<T, U, ReturningClause<T::AllColumns>>: Query,

type SqlType = <<DeleteStatement<T, U> as AsQuery>::Query as Query>::SqlType

type Query = DeleteStatement<T, U, ReturningClause<<T as Table>::AllColumns>>

impl<T, U, Op> AsQuery for InsertStatement<T, U, Op, NoReturningClause>

where T: Table, InsertStatement<T, U, Op, ReturningClause<T::AllColumns>>: Query,

type SqlType = <<InsertStatement<T, U, Op> as AsQuery>::Query as Query>::SqlType

type Query = InsertStatement<T, U, Op, ReturningClause<<T as Table>::AllColumns>>

impl<T, U, V> AsQuery for UpdateStatement<T, U, V, NoReturningClause>

where T: Table, UpdateStatement<T, U, V, ReturningClause<T::AllColumns>>: Query, T::AllColumns: ValidGrouping<()>, <T::AllColumns as ValidGrouping<()>>::IsAggregate: MixedAggregates<No, Output = No>,

type SqlType = <<UpdateStatement<T, U, V> as AsQuery>::Query as Query>::SqlType

type Query = UpdateStatement<T, U, V, ReturningClause<<T as Table>::AllColumns>>

impl<T: Query> AsQuery for T

type SqlType = <T as Query>::SqlType

type Query = T