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.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

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

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

Available on crate feature postgres_backend only.

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

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

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>>,

Available on crate feature postgres_backend only.

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

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

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

where T: Table, U: InsertStmtKind, InsertStatement<T, U, Op, ReturningClause<T::AllColumns>>: Query, T::AllColumns: SelectableExpression<ReturningQuerySource<U::StmtKind, T>>,

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: SelectableExpression<ReturningQuerySource<UpdateStmt, T>> + 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, U> AsQuery for DeleteStatement<T, U, NoReturningClause>

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

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

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

impl<T: Query> AsQuery for T

type SqlType = <T as Query>::SqlType

type Query = T