Skip to main content

table

autumn_admin_plugin::experiments::autumn_experiment_changes

Struct table

pub struct table;

Expand description

The actual table struct

This is the type which provides the base methods of the query builder, such as .select and .filter.

Implementations§

impl table

pub fn star(&self) -> star

Represents table_name.*, which is sometimes necessary for efficient count queries. It cannot be used in place of all_columns

Trait Implementations§

impl<S1, S2> AliasAliasAppearsInFromClause<table, S2, S1> for table
where S1: AliasSource<Target = table> + AliasAliasAppearsInFromClauseSameTable<S2, table>, S2: AliasSource<Target = table>,

type Count = <S1 as AliasAliasAppearsInFromClauseSameTable<S2, table>>::Count

Will be passed on to the impl AppearsInFromClause<QS>

impl<S> AliasAppearsInFromClause<S, table> for table
where S: AliasSource<Target = table>,

type Count = Never

Will be passed on to the impl AppearsInFromClause<QS>

impl<S> AppearsInFromClause<Alias<S>> for table
where S: AliasSource,

type Count = Never

How many times does Self appear in QS?

impl AppearsInFromClause<Only<table>> for table

type Count = Once

How many times does Self appear in QS?

impl<TSM> AppearsInFromClause<Tablesample<table, TSM>> for table
where TSM: TablesampleMethod,

type Count = Once

How many times does Self appear in QS?

impl AppearsInFromClause<table> for table

type Count = Once

How many times does Self appear in QS?

impl AppearsInFromClause<table> for NoFromClause

type Count = Never

How many times does Self appear in QS?

impl AppearsInFromClause<table> for Only<table>

type Count = Once

How many times does Self appear in QS?

impl<TSM> AppearsInFromClause<table> for Tablesample<table, TSM>
where TSM: TablesampleMethod,

type Count = Once

How many times does Self appear in QS?

impl AppearsOnTable<table> for star

impl AsQuery for table

type SqlType = (BigInt, Text, Text, Nullable<Text>, Timestamp)

The SQL type of Self::Query

type Query = SelectStatement<FromClause<table>>

What kind of query does this type represent?

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.

impl Clone for table

fn clone(&self) -> Self

Returns a duplicate of the value. Read more

1.0.0 (const: unstable) · Source§

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

Performs copy-assignment from source. Read more

impl Copy for table

impl Debug for table

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

Formats the value using the given formatter. Read more

impl Default for table

fn default() -> Self

Returns the “default value” for a type. Read more

impl HasTable for table

type Table = table

The table this type is associated with.

fn table() -> Self::Table

Returns the table this type is associated with.

impl<T> Insertable<T> for table
where <table as AsQuery>::Query: Insertable<T>,

type Values = <<table as AsQuery>::Query as Insertable<T>>::Values

The VALUES clause to insert these records Read more

fn values(self) -> Self::Values

Construct Self::Values Read more

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values>
where T: Table, Self: Sized,

Insert self into a given table. Read more

impl<'a, T> Insertable<T> for &'a table
where table: Insertable<T>,

type Values = <table as Insertable<T>>::Values

The VALUES clause to insert these records Read more

fn values(self) -> Self::Values

Construct Self::Values Read more

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values>
where T: Table, Self: Sized,

Insert self into a given table. Read more

impl Insertable<table> for ExperimentChange
where i64: AsExpression<<id as Expression>::SqlType>, String: AsExpression<<experiment as Expression>::SqlType> + AsExpression<<mutation as Expression>::SqlType> + AsExpression<<actor as Expression>::SqlType>, NaiveDateTime: AsExpression<<changed_at as Expression>::SqlType>,

type Values = <(Option<Grouped<Eq<id, <i64 as AsExpression<<id as Expression>::SqlType>>::Expression>>>, Option<Grouped<Eq<experiment, <String as AsExpression<<experiment as Expression>::SqlType>>::Expression>>>, Option<Grouped<Eq<mutation, <String as AsExpression<<mutation as Expression>::SqlType>>::Expression>>>, Option<Grouped<Eq<actor, <String as AsExpression<<actor as Expression>::SqlType>>::Expression>>>, Option<Grouped<Eq<changed_at, <NaiveDateTime as AsExpression<<changed_at as Expression>::SqlType>>::Expression>>>) as Insertable<table>>::Values

The VALUES clause to insert these records Read more

fn values( self, ) -> <(Option<Eq<id, i64>>, Option<Eq<experiment, String>>, Option<Eq<mutation, String>>, Option<Eq<actor, String>>, Option<Eq<changed_at, NaiveDateTime>>) as Insertable<table>>::Values

Construct Self::Values Read more

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values>
where T: Table, Self: Sized,

Insert self into a given table. Read more

impl<'insert> Insertable<table> for &'insert ExperimentChange
where &'insert i64: AsExpression<<id as Expression>::SqlType>, &'insert String: AsExpression<<experiment as Expression>::SqlType> + AsExpression<<mutation as Expression>::SqlType> + AsExpression<<actor as Expression>::SqlType>, &'insert NaiveDateTime: AsExpression<<changed_at as Expression>::SqlType>,

type Values = <(Option<Grouped<Eq<id, <&'insert i64 as AsExpression<<id as Expression>::SqlType>>::Expression>>>, Option<Grouped<Eq<experiment, <&'insert String as AsExpression<<experiment as Expression>::SqlType>>::Expression>>>, Option<Grouped<Eq<mutation, <&'insert String as AsExpression<<mutation as Expression>::SqlType>>::Expression>>>, Option<Grouped<Eq<actor, <&'insert String as AsExpression<<actor as Expression>::SqlType>>::Expression>>>, Option<Grouped<Eq<changed_at, <&'insert NaiveDateTime as AsExpression<<changed_at as Expression>::SqlType>>::Expression>>>) as Insertable<table>>::Values

The VALUES clause to insert these records Read more

fn values( self, ) -> <(Option<Eq<id, &'insert i64>>, Option<Eq<experiment, &'insert String>>, Option<Eq<mutation, &'insert String>>, Option<Eq<actor, &'insert String>>, Option<Eq<changed_at, &'insert NaiveDateTime>>) as Insertable<table>>::Values

Construct Self::Values Read more

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values>
where T: Table, Self: Sized,

Insert self into a given table. Read more

impl Insertable<table> for NewExperimentChange
where String: AsExpression<<experiment as Expression>::SqlType> + AsExpression<<mutation as Expression>::SqlType> + AsExpression<<actor as Expression>::SqlType>,

type Values = <(Option<Grouped<Eq<experiment, <String as AsExpression<<experiment as Expression>::SqlType>>::Expression>>>, Option<Grouped<Eq<mutation, <String as AsExpression<<mutation as Expression>::SqlType>>::Expression>>>, Option<Grouped<Eq<actor, <String as AsExpression<<actor as Expression>::SqlType>>::Expression>>>) as Insertable<table>>::Values

The VALUES clause to insert these records Read more

fn values( self, ) -> <(Option<Eq<experiment, String>>, Option<Eq<mutation, String>>, Option<Eq<actor, String>>) as Insertable<table>>::Values

Construct Self::Values Read more

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values>
where T: Table, Self: Sized,

Insert self into a given table. Read more

impl<'insert> Insertable<table> for &'insert NewExperimentChange
where &'insert String: AsExpression<<experiment as Expression>::SqlType> + AsExpression<<mutation as Expression>::SqlType> + AsExpression<<actor as Expression>::SqlType>,

type Values = <(Option<Grouped<Eq<experiment, <&'insert String as AsExpression<<experiment as Expression>::SqlType>>::Expression>>>, Option<Grouped<Eq<mutation, <&'insert String as AsExpression<<mutation as Expression>::SqlType>>::Expression>>>, Option<Grouped<Eq<actor, <&'insert String as AsExpression<<actor as Expression>::SqlType>>::Expression>>>) as Insertable<table>>::Values

The VALUES clause to insert these records Read more

fn values( self, ) -> <(Option<Eq<experiment, &'insert String>>, Option<Eq<mutation, &'insert String>>, Option<Eq<actor, &'insert String>>) as Insertable<table>>::Values

Construct Self::Values Read more

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values>
where T: Table, Self: Sized,

Insert self into a given table. Read more

impl IntoUpdateTarget for table

type WhereClause = <<table as AsQuery>::Query as IntoUpdateTarget>::WhereClause

What is the WHERE clause of this target?

fn into_update_target(self) -> UpdateTarget<Self::Table, Self::WhereClause>

Decomposes self into the table and where clause.

impl<S> JoinTo<Alias<S>> for table
where Alias<S>: JoinTo<table>,

impl<Left, Right, Kind> JoinTo<Join<Left, Right, Kind>> for table
where Join<Left, Right, Kind>: JoinTo<table>, Left: QuerySource, Right: QuerySource,

impl<S> JoinTo<Only<S>> for table
where Only<S>: JoinTo<table>,

impl<S, TSM> JoinTo<Tablesample<S, TSM>> for table
where Tablesample<S, TSM>: JoinTo<table>, TSM: TablesampleMethod,

impl<DB> QueryFragment<DB> for table
where DB: Backend, <table as StaticQueryFragment>::Component: QueryFragment<DB>,

fn walk_ast<'b>( &'b self, __diesel_internal_pass: AstPass<'_, 'b, DB>, ) -> QueryResult<()>

Walk over this QueryFragment for all passes. Read more

fn to_sql( &self, out: &mut <DB as Backend>::QueryBuilder, backend: &DB, ) -> Result<(), Error>

Converts this QueryFragment to its SQL representation. Read more

fn collect_binds<'b>( &'b self, out: &mut <DB as Backend>::BindCollector<'b>, metadata_lookup: &mut <DB as TypeMetadata>::MetadataLookup, backend: &'b DB, ) -> Result<(), Error>

Serializes all bind parameters in this query. Read more

fn is_safe_to_cache_prepared(&self, backend: &DB) -> Result<bool, Error>

Is this query safe to store in the prepared statement cache? Read more

fn is_noop(&self, backend: &DB) -> Result<bool, Error>

Does walking this AST have any effect?

impl QueryId for table

const HAS_STATIC_QUERY_ID: bool = true

Can the SQL generated by Self be uniquely identified by its type? Read more

type QueryId = table

A type which uniquely represents Self in a SQL query. Read more

fn query_id() -> Option<TypeId>

Returns the type id of Self::QueryId if Self::HAS_STATIC_QUERY_ID. Returns None otherwise. Read more

impl QuerySource for table

type FromClause = StaticQueryFragmentInstance<table>

The type returned by from_clause

type DefaultSelection = <table as Table>::AllColumns

The type returned by default_selection

fn from_clause(&self) -> Self::FromClause

The actual FROM clause of this type. This is typically only called in QueryFragment implementations.

fn default_selection(&self) -> Self::DefaultSelection

The default select clause of this type, which should be used if no select clause was explicitly specified. This should always be a tuple of all the desired columns, not star

impl SelectableExpression<table> for star

impl SelectableExpression<table> for id

impl SelectableExpression<table> for experiment

impl SelectableExpression<table> for mutation

impl SelectableExpression<table> for actor

impl SelectableExpression<table> for changed_at

impl Table for table

type PrimaryKey = id

The type returned by primary_key

type AllColumns = (id, experiment, mutation, actor, changed_at)

The type returned by all_columns

fn primary_key(&self) -> Self::PrimaryKey

Returns the primary key of this table. Read more

fn all_columns() -> Self::AllColumns

Returns a tuple of all columns belonging to this table.

impl UndecoratedInsertRecord<table> for ExperimentChange

impl UndecoratedInsertRecord<table> for NewExperimentChange

Auto Trait Implementations§

impl Freeze for table

impl RefUnwindSafe for table

impl Send for table

impl Sync for table

impl Unpin for table

impl UnsafeUnpin for table

impl UnwindSafe for table

Blanket Implementations§

impl<T> AggregateExpressionMethods for T

fn aggregate_distinct(self) -> Self::Output
where Self: DistinctDsl,

DISTINCT modifier for aggregate functions Read more

fn aggregate_all(self) -> Self::Output
where Self: AllDsl,

ALL modifier for aggregate functions Read more

fn aggregate_filter<P>(self, f: P) -> Self::Output
where P: AsExpression<Bool>, Self: FilterDsl<<P as AsExpression<Bool>>::Expression>,

Add an aggregate function filter Read more

fn aggregate_order<O>(self, o: O) -> Self::Output
where Self: OrderAggregateDsl<O>,

Add an aggregate function order Read more

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> AutumnCounterCaches for T
where T: 'static,

const HAS_COUNTER_CACHES: bool = false

Whether this model has any counter cache at all. Read more

fn counter_caches() -> &'static [CounterCacheSpec<Self>]

The model’s counter-cache specs, in declaration order.

impl<T> AutumnDependents for T
where T: ?Sized,

fn dependents() -> &'static [RuntimeDependentSpec]

The model’s dependent-cascade specs, in declaration order. Defaults to none; #[model] overrides via an inherent shadow when dependents exist.

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<'a, T, DB> BoxedDsl<'a, DB> for T
where T: Table<Query = SelectStatement<FromClause<T>>> + AsQuery, SelectStatement<FromClause<T>>: BoxedDsl<'a, DB>, <T as QuerySource>::DefaultSelection: Expression<SqlType = <T as AsQuery>::SqlType> + ValidGrouping<()>, <T as AsQuery>::SqlType: TypedExpressionType,

type Output = <SelectStatement<FromClause<T>> as BoxedDsl<'a, DB>>::Output

The return type of internal_into_boxed

fn internal_into_boxed(self) -> <T as BoxedDsl<'a, DB>>::Output

See the trait documentation.

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)

Performs copy-assignment from self to dest. Read more

impl<T> CombineDsl for T
where T: Table,

type Query = <T as AsQuery>::Query

What kind of query does this type represent?

fn union<Rhs>( self, rhs: Rhs, ) -> CombinationClause<Union, Distinct, <T as CombineDsl>::Query, <Rhs as AsQuery>::Query>
where Rhs: AsQuery<SqlType = <<T as CombineDsl>::Query as Query>::SqlType>,

Combine two queries using a SQL UNION Read more

fn union_all<Rhs>( self, rhs: Rhs, ) -> CombinationClause<Union, All, <T as CombineDsl>::Query, <Rhs as AsQuery>::Query>
where Rhs: AsQuery<SqlType = <<T as CombineDsl>::Query as Query>::SqlType>,

Combine two queries using a SQL UNION ALL

fn intersect<Rhs>( self, rhs: Rhs, ) -> CombinationClause<Intersect, Distinct, <T as CombineDsl>::Query, <Rhs as AsQuery>::Query>
where Rhs: AsQuery<SqlType = <<T as CombineDsl>::Query as Query>::SqlType>,

Combine two queries using a SQL INTERSECT

fn intersect_all<Rhs>( self, rhs: Rhs, ) -> CombinationClause<Intersect, All, <T as CombineDsl>::Query, <Rhs as AsQuery>::Query>
where Rhs: AsQuery<SqlType = <<T as CombineDsl>::Query as Query>::SqlType>,

Combine two queries using a SQL INTERSECT ALL

fn except<Rhs>( self, rhs: Rhs, ) -> CombinationClause<Except, Distinct, <T as CombineDsl>::Query, <Rhs as AsQuery>::Query>
where Rhs: AsQuery<SqlType = <<T as CombineDsl>::Query as Query>::SqlType>,

Combine two queries using a SQL EXCEPT

fn except_all<Rhs>( self, rhs: Rhs, ) -> CombinationClause<Except, All, <T as CombineDsl>::Query, <Rhs as AsQuery>::Query>
where Rhs: AsQuery<SqlType = <<T as CombineDsl>::Query as Query>::SqlType>,

Combine two queries using a SQL EXCEPT ALL

impl<T> CopyTarget for T
where T: Table + StaticQueryFragment, <T as AsQuery>::SqlType: SqlType, <T as Table>::AllColumns: ColumnList, <T as StaticQueryFragment>::Component: QueryFragment<Pg>,

type Table = T

The table targeted by the command

type SqlType = <T as AsQuery>::SqlType

The sql side type of the target expression

fn walk_target(pass: AstPass<'_, '_, Pg>) -> Result<(), Error>

impl<T> DistinctDsl for T
where T: AsQuery<Query = SelectStatement<FromClause<T>>> + Table, <T as QuerySource>::DefaultSelection: Expression<SqlType = <T as AsQuery>::SqlType> + ValidGrouping<()>, <T as AsQuery>::SqlType: TypedExpressionType,

type Output = <SelectStatement<FromClause<T>> as DistinctDsl>::Output

The type returned by .distinct

fn distinct(self) -> <SelectStatement<FromClause<T>> as DistinctDsl>::Output

See the trait documentation.

impl<T, Selection> DistinctOnDsl<Selection> for T
where Selection: SelectableExpression<T>, T: Table<Query = SelectStatement<FromClause<T>>> + AsQuery, SelectStatement<FromClause<T>>: DistinctOnDsl<Selection>, <T as QuerySource>::DefaultSelection: Expression<SqlType = <T as AsQuery>::SqlType> + ValidGrouping<()>, <T as AsQuery>::SqlType: TypedExpressionType,

type Output = <SelectStatement<FromClause<T>> as DistinctOnDsl<Selection>>::Output

The type returned by .distinct_on

fn distinct_on( self, selection: Selection, ) -> <T as DistinctOnDsl<Selection>>::Output

See the trait documentation

impl<T> Downcast for T
where T: Any,

fn into_any(self: Box<T>) -> Box<dyn Any>

Converts Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Converts Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.

fn as_any(&self) -> &(dyn Any + 'static)

Converts &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Converts &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.

impl<T> DowncastSend for T
where T: Any + Send,

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

Converts Box<Trait> (where Trait: DowncastSend) to Box<dyn Any + Send>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.

impl<T> DowncastSync for T
where T: Any + Send + Sync,

fn into_any_sync(self: Box<T>) -> Box<dyn Any + Sync + Send>

Converts Box<Trait> (where Trait: DowncastSync) to Box<dyn Any + Send + Sync>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send> ⓘ

Converts Arc<Trait> (where Trait: DowncastSync) to Arc<Any>, which can then be downcast into Arc<ConcreteType> where ConcreteType implements Trait.

impl<Conn, DB, T> ExecuteDsl<Conn, DB> for T
where Conn: AsyncConnectionCore<Backend = DB>, DB: Backend, T: QueryFragment<DB> + QueryId + Send,

fn execute<'conn, 'query>( query: T, conn: &'conn mut Conn, ) -> <Conn as AsyncConnectionCore>::ExecuteFuture<'conn, 'query>
where T: 'query,

Execute this command

impl<Conn, DB, T> ExecuteDsl<Conn, DB> for T
where Conn: Connection<Backend = DB>, DB: Backend, T: QueryFragment<DB> + QueryId,

fn execute(query: T, conn: &mut Conn) -> Result<usize, Error>

Execute this command

impl<T, Predicate> FilterDsl<Predicate> for T
where T: Table, <T as AsQuery>::Query: FilterDsl<Predicate>,

type Output = <<T as AsQuery>::Query as FilterDsl<Predicate>>::Output

The type returned by .filter.

fn filter(self, predicate: Predicate) -> <T as FilterDsl<Predicate>>::Output

See the trait documentation.

impl<T, PK> FindDsl<PK> for T
where T: Table + FilterDsl<<<T as Table>::PrimaryKey as EqAll<PK>>::Output>, <T as Table>::PrimaryKey: EqAll<PK>,

type Output = <T as FilterDsl<<<T as Table>::PrimaryKey as EqAll<PK>>::Output>>::Output

The type returned by .find.

fn find(self, id: PK) -> <T as FindDsl<PK>>::Output

See the trait documentation.

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> FromRef<T> for T
where T: Clone,

fn from_ref(input: &T) -> T

Converts to this type from a reference to the input type.

impl<T, Expr> GroupByDsl<Expr> for T
where Expr: Expression, T: Table<Query = SelectStatement<FromClause<T>>> + AsQuery, <T as QuerySource>::DefaultSelection: Expression<SqlType = <T as AsQuery>::SqlType> + ValidGrouping<()>, <T as AsQuery>::SqlType: TypedExpressionType, <T as AsQuery>::Query: GroupByDsl<Expr>,

type Output = <SelectStatement<FromClause<T>> as GroupByDsl<Expr>>::Output

The type returned by .group_by

fn group_by(self, expr: Expr) -> <T as GroupByDsl<Expr>>::Output

See the trait documentation.

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into<U> for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> IntoSql for T

fn into_sql<T>(self) -> Self::Expression
where Self: Sized + AsExpression<T>, T: SqlType + TypedExpressionType,

Convert self to an expression for Diesel’s query builder. Read more

fn as_sql<'a, T>(&'a self) -> <&'a Self as AsExpression<T>>::Expression
where &'a Self: AsExpression<T>, T: SqlType + TypedExpressionType,

Convert &self to an expression for Diesel’s query builder. Read more

impl<T> JoinOnDsl for T
where T: QuerySource,

fn on<On>(self, on: On) -> OnClauseWrapper<Self, On>

See the trait documentation.

impl<Lhs, Rhs, On> JoinTo<OnClauseWrapper<Rhs, On>> for Lhs
where Lhs: Table,

type FromClause = Rhs

type OnClause = On

fn join_target( rhs: OnClauseWrapper<Rhs, On>, ) -> (<Lhs as JoinTo<OnClauseWrapper<Rhs, On>>>::FromClause, <Lhs as JoinTo<OnClauseWrapper<Rhs, On>>>::OnClause)

impl<T> LimitDsl for T
where T: Table, <T as AsQuery>::Query: LimitDsl,

type Output = <<T as AsQuery>::Query as LimitDsl>::Output

The type returned by .limit

fn limit(self, limit: i64) -> <T as LimitDsl>::Output

See the trait documentation

impl<'query, Conn, T, U, DB, B> LoadQuery<'query, Conn, U, B> for T
where Conn: Connection<Backend = DB> + LoadConnection<B>, T: AsQuery + RunQueryDsl<Conn>, <T as AsQuery>::Query: QueryFragment<DB> + QueryId + 'query, <T as AsQuery>::SqlType: CompatibleType<U, DB>, DB: Backend + QueryMetadata<<T as AsQuery>::SqlType> + 'static, U: FromSqlRow<<<T as AsQuery>::SqlType as CompatibleType<U, DB>>::SqlType, DB> + 'static, <<T as AsQuery>::SqlType as CompatibleType<U, DB>>::SqlType: 'static,

type RowIter<'conn> = LoadIter<U, <Conn as LoadConnection<B>>::Cursor<'conn, 'query>, <<T as AsQuery>::SqlType as CompatibleType<U, DB>>::SqlType, DB>
where Conn: 'conn,

Return type of LoadQuery::internal_load

fn internal_load( self, conn: &mut Conn, ) -> Result<<T as LoadQuery<'query, Conn, U, B>>::RowIter<'_>, Error>

Load this query

impl<'query, Conn, DB, T, U, ST> LoadQuery<'query, Conn, U> for T
where Conn: AsyncConnectionCore<Backend = DB>, U: Send + FromSqlRow<ST, DB> + 'static, DB: Backend + 'static + QueryMetadata<<T as AsQuery>::SqlType>, T: AsQuery + Send + 'query, <T as AsQuery>::Query: QueryFragment<DB> + QueryId + Send + 'query, <T as AsQuery>::SqlType: CompatibleType<U, DB, SqlType = ST>, ST: 'static,

type LoadFuture<'conn> = MapOk<<Conn as AsyncConnectionCore>::LoadFuture<'conn, 'query>, <T as LoadQuery<'query, Conn, U>>::Stream<'conn>>
where Conn: 'conn,

The future returned by LoadQuery::internal_load

type Stream<'conn> = Map<<Conn as AsyncConnectionCore>::Stream<'conn, 'query>, fn(Result<<Conn as AsyncConnectionCore>::Row<'conn, 'query>, Error>) -> Result<U, Error>>
where Conn: 'conn,

The inner stream returned by LoadQuery::internal_load

fn internal_load( self, conn: &mut Conn, ) -> <T as LoadQuery<'query, Conn, U>>::LoadFuture<'_>

Load this query

impl<T, Lock> LockingDsl<Lock> for T
where T: Table<Query = SelectStatement<FromClause<T>>> + AsQuery, <T as QuerySource>::DefaultSelection: Expression<SqlType = <T as AsQuery>::SqlType> + ValidGrouping<()>, <T as AsQuery>::SqlType: TypedExpressionType,

type Output = <SelectStatement<FromClause<T>> as LockingDsl<Lock>>::Output

The type returned by set_lock. See dsl::ForUpdate and friends for convenient access to this type.

fn with_lock(self, lock: Lock) -> <T as LockingDsl<Lock>>::Output

See the trait level documentation

impl<T> OffsetDsl for T
where T: Table, <T as AsQuery>::Query: OffsetDsl,

type Output = <<T as AsQuery>::Query as OffsetDsl>::Output

The type returned by .offset.

fn offset(self, offset: i64) -> <T as OffsetDsl>::Output

See the trait documentation

impl<T> OnlyDsl for T
where T: Table,

fn only(self) -> Only<Self>

See the trait-level docs.

impl<T, Predicate> OrFilterDsl<Predicate> for T
where T: Table, <T as AsQuery>::Query: OrFilterDsl<Predicate>,

type Output = <<T as AsQuery>::Query as OrFilterDsl<Predicate>>::Output

The type returned by .filter.

fn or_filter( self, predicate: Predicate, ) -> <T as OrFilterDsl<Predicate>>::Output

See the trait documentation.

impl<T, Expr> OrderDsl<Expr> for T
where Expr: Expression, T: Table, <T as AsQuery>::Query: OrderDsl<Expr>,

type Output = <<T as AsQuery>::Query as OrderDsl<Expr>>::Output

The type returned by .order.

fn order(self, expr: Expr) -> <T as OrderDsl<Expr>>::Output

See the trait documentation.

impl<T> Pointable for T

const ALIGN: usize

The alignment of pointer.

type Init = T

The type for initializers.

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more

impl<T> PolicyExt for T
where T: ?Sized,

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Sized + Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow only if self and other return Action::Follow. Read more

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Sized + Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow if either self or other returns Action::Follow. Read more

impl<T> QueryDsl for T
where T: Table,

fn distinct(self) -> Self::Output
where Self: DistinctDsl,

Adds the DISTINCT keyword to a query. Read more

fn distinct_on<Expr>(self, expr: Expr) -> Self::Output
where Self: DistinctOnDsl<Expr>,

Adds the DISTINCT ON clause to a query. Read more

fn select<Selection>(self, selection: Selection) -> Self::Output
where Selection: Expression, Self: SelectDsl<Selection>,

Adds a SELECT clause to the query. Read more

fn count(self) -> Self::Output
where Self: SelectDsl<CountStar>,

Get the count of a query. This is equivalent to .select(count_star()) Read more

fn inner_join<Rhs>(self, rhs: Rhs) -> Self::Output
where Self: JoinWithImplicitOnClause<Rhs, Inner>,

Join two tables using a SQL INNER JOIN. Read more

fn left_outer_join<Rhs>(self, rhs: Rhs) -> Self::Output
where Self: JoinWithImplicitOnClause<Rhs, LeftOuter>,

Join two tables using a SQL LEFT OUTER JOIN. Read more

fn left_join<Rhs>(self, rhs: Rhs) -> Self::Output
where Self: JoinWithImplicitOnClause<Rhs, LeftOuter>,

Alias for left_outer_join.

fn filter<Predicate>(self, predicate: Predicate) -> Self::Output
where Self: FilterDsl<Predicate>,

Adds to the WHERE clause of a query. Read more

fn or_filter<Predicate>(self, predicate: Predicate) -> Self::Output
where Self: OrFilterDsl<Predicate>,

Adds to the WHERE clause of a query using OR Read more

fn find<PK>(self, id: PK) -> Self::Output
where Self: FindDsl<PK>,

Attempts to find a single record from the given table by primary key. Read more

fn order<Expr>(self, expr: Expr) -> Self::Output
where Expr: Expression, Self: OrderDsl<Expr>,

Sets the order clause of a query. Read more

fn order_by<Expr>(self, expr: Expr) -> Self::Output
where Expr: Expression, Self: OrderDsl<Expr>,

Alias for order

fn then_order_by<Order>(self, order: Order) -> Self::Output
where Self: ThenOrderDsl<Order>,

Appends to the ORDER BY clause of this SQL query. Read more

fn limit(self, limit: i64) -> Self::Output
where Self: LimitDsl,

Sets the limit clause of the query. Read more

fn offset(self, offset: i64) -> Self::Output
where Self: OffsetDsl,

Sets the offset clause of the query. Read more

fn group_by<GB>(self, group_by: GB) -> Self::Output
where GB: Expression, Self: GroupByDsl<GB>,

Sets the group by clause of a query. Read more

fn having<Predicate>(self, predicate: Predicate) -> Self::Output
where Self: HavingDsl<Predicate>,

Adds to the HAVING clause of a query. Read more

fn for_update(self) -> Self::Output
where Self: LockingDsl<ForUpdate>,

Adds FOR UPDATE to the end of the select statement. Read more

fn for_no_key_update(self) -> Self::Output
where Self: LockingDsl<ForNoKeyUpdate>,

Adds FOR NO KEY UPDATE to the end of the select statement. Read more

fn for_share(self) -> Self::Output
where Self: LockingDsl<ForShare>,

Adds FOR SHARE to the end of the select statement. Read more

fn for_key_share(self) -> Self::Output
where Self: LockingDsl<ForKeyShare>,

Adds FOR KEY SHARE to the end of the select statement. Read more

fn skip_locked(self) -> Self::Output
where Self: ModifyLockDsl<SkipLocked>,

Adds SKIP LOCKED to the end of a FOR UPDATE clause. Read more

fn no_wait(self) -> Self::Output
where Self: ModifyLockDsl<NoWait>,

Adds NOWAIT to the end of a FOR UPDATE clause. Read more

fn into_boxed<'a, DB>(self) -> Self::Output
where DB: Backend, Self: BoxedDsl<'a, DB>,

Boxes the pieces of a query into a single type. Read more

fn single_value(self) -> Self::Output
where Self: SingleValueDsl,

Wraps this select statement in parenthesis, allowing it to be used as an expression. Read more

fn nullable(self) -> Self::Output
where Self: SelectNullableDsl,

Coerce the SQL type of the select clause to it’s nullable equivalent. Read more

impl<T, DB> QueryFragmentForCachedStatement<DB> for T
where DB: Backend, <DB as Backend>::QueryBuilder: Default, T: QueryFragment<DB>,

fn construct_sql(&self, backend: &DB) -> Result<String, Error>

Convert the query fragment into a SQL string for the given backend

fn is_safe_to_cache_prepared(&self, backend: &DB) -> Result<bool, Error>

Check whether it’s safe to cache the query

impl<T> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

impl<T> RepositoryHooksClone for T
where T: Clone,

fn autumn_clone(&self) -> T

Clone hook state for generated repository values.

impl<T> RepositoryHooksDefault for T
where T: Default,

fn autumn_default() -> T

Construct a hook instance for generated repository state.

impl<T, Conn> RunQueryDsl<Conn> for T

fn execute<'conn, 'query>( self, conn: &'conn mut Conn, ) -> <Conn as AsyncConnectionCore>::ExecuteFuture<'conn, 'query>
where Conn: AsyncConnectionCore + Send, Self: ExecuteDsl<Conn> + 'query,

Executes the given command, returning the number of rows affected. Read more

fn load<'query, 'conn, U>( self, conn: &'conn mut Conn, ) -> AndThen<Self::LoadFuture<'conn>, TryCollect<Self::Stream<'conn>, Vec<U>>>
where U: Send, Conn: AsyncConnectionCore, Self: LoadQuery<'query, Conn, U> + 'query,

Executes the given query, returning a Vec with the returned rows. Read more

fn load_stream<'conn, 'query, U>( self, conn: &'conn mut Conn, ) -> Self::LoadFuture<'conn>
where Conn: AsyncConnectionCore, U: 'conn, Self: LoadQuery<'query, Conn, U> + 'query,

Executes the given query, returning a [Stream] with the returned rows. Read more

fn get_result<'query, 'conn, U>( self, conn: &'conn mut Conn, ) -> AndThen<Self::LoadFuture<'conn>, LoadNext<Pin<Box<Self::Stream<'conn>>>>>
where U: Send + 'conn, Conn: AsyncConnectionCore, Self: LoadQuery<'query, Conn, U> + 'query,

Runs the command, and returns the affected row. Read more

fn get_results<'query, 'conn, U>( self, conn: &'conn mut Conn, ) -> AndThen<Self::LoadFuture<'conn>, TryCollect<Self::Stream<'conn>, Vec<U>>>
where U: Send, Conn: AsyncConnectionCore, Self: LoadQuery<'query, Conn, U> + 'query,

Runs the command, returning an Vec with the affected rows. Read more

fn first<'query, 'conn, U>( self, conn: &'conn mut Conn, ) -> AndThen<<Self::Output as LoadQuery<'query, Conn, U>>::LoadFuture<'conn>, LoadNext<Pin<Box<<Self::Output as LoadQuery<'query, Conn, U>>::Stream<'conn>>>>>
where U: Send + 'conn, Conn: AsyncConnectionCore, Self: LimitDsl, Self::Output: LoadQuery<'query, Conn, U> + Send + 'query,

Attempts to load a single record. Read more

impl<T, Conn> RunQueryDsl<Conn> for T
where T: Table,

fn execute(self, conn: &mut Conn) -> Result<usize, Error>
where Conn: Connection, Self: ExecuteDsl<Conn>,

Executes the given command, returning the number of rows affected. Read more

fn load<'query, U>(self, conn: &mut Conn) -> Result<Vec<U>, Error>
where Self: LoadQuery<'query, Conn, U>,

Executes the given query, returning a Vec with the returned rows. Read more

fn load_iter<'conn, 'query, U, B>( self, conn: &'conn mut Conn, ) -> Result<Self::RowIter<'conn>, Error>
where 'query: 'conn, U: 'conn, Self: LoadQuery<'query, Conn, U, B> + 'conn,

Executes the given query, returning an Iterator with the returned rows. Read more

fn get_result<'query, U>(self, conn: &mut Conn) -> Result<U, Error>
where Self: LoadQuery<'query, Conn, U>,

Runs the command, and returns the affected row. Read more

fn get_results<'query, U>(self, conn: &mut Conn) -> Result<Vec<U>, Error>
where Self: LoadQuery<'query, Conn, U>,

Runs the command, returning an Vec with the affected rows. Read more

fn first<'query, U>(self, conn: &mut Conn) -> Result<U, Error>
where Self: LimitDsl, Self::Output: LoadQuery<'query, Conn, U>,

Attempts to load a single record. Read more

impl<T> Same for T

type Output = T

Should always be Self

impl<T> Scoped for T
where T: Send + Sync + 'static,

fn scope(ctx: &PolicyContext) -> ScopeQuery<'_, Self>

Open a deferred ScopeQuery for this type. Resolves the registered scope at .load() time, not here.

impl<T, Selection> SelectDsl<Selection> for T
where Selection: Expression, T: Table, <T as AsQuery>::Query: SelectDsl<Selection>,

type Output = <<T as AsQuery>::Query as SelectDsl<Selection>>::Output

The type returned by .select

fn select(self, selection: Selection) -> <T as SelectDsl<Selection>>::Output

See the trait documentation

impl<T> TablesampleDsl for T
where T: Table,

fn tablesample_bernoulli( self, portion: i16, ) -> Tablesample<Self, BernoulliMethod>

See the trait-level docs.

fn tablesample_system(self, portion: i16) -> Tablesample<Self, SystemMethod>

See the trait-level docs.

impl<T, Expr> ThenOrderDsl<Expr> for T
where Expr: Expression, T: Table, <T as AsQuery>::Query: ThenOrderDsl<Expr>,

type Output = <<T as AsQuery>::Query as ThenOrderDsl<Expr>>::Output

The type returned by .then_order_by.

fn then_order_by(self, expr: Expr) -> <T as ThenOrderDsl<Expr>>::Output

See the trait documentation.

impl<T> ToOwned for T
where T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom<U> for T
where U: Into<T>,

type Error = !

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, !>

Performs the conversion.

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn vzip(self) -> V

impl<T> WindowExpressionMethods for T

fn over(self) -> Self::Output
where Self: OverDsl,

Turn a function call into a window function call Read more

fn window_filter<P>(self, f: P) -> Self::Output
where P: AsExpression<Bool>, Self: FilterDsl<<P as AsExpression<Bool>>::Expression>,

Add a filter to the current window function Read more

fn partition_by<E>(self, expr: E) -> Self::Output
where Self: PartitionByDsl<E>,

Add a partition clause to the current window function Read more

fn window_order<E>(self, expr: E) -> Self::Output
where Self: OrderWindowDsl<E>,

Add a order clause to the current window function Read more

fn frame_by<E>(self, expr: E) -> Self::Output
where Self: FrameDsl<E>,

Add a frame clause to the current window function Read more

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘ
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more