Struct diesel::expression::Concat

#[non_exhaustive]
pub struct Concat<L, R> {
    pub left: L,
    pub right: R,
}

This type represents a string concat operator

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

left: L

The left side expression of the operator

right: R

The right side expression of the operator

Trait Implementations

impl<L, R, __Rhs> Add<__Rhs> for Concat<L, R>where Self: Expression, <Self as Expression>::SqlType: Add, <<Self as Expression>::SqlType as Add>::Rhs: SqlType + SingleValue, __Rhs: AsExpression<<<Self as Expression>::SqlType as Add>::Rhs>,

type Output = Add<Concat<L, R>, <__Rhs as AsExpression<<<Concat<L, R> as Expression>::SqlType as Add>::Rhs>>::Expression>

The resulting type after applying the + operator.

fn add(self, rhs: __Rhs) -> Self::Output

Performs the + operation.

impl<L: Clone, R: Clone> Clone for Concat<L, R>

fn clone(&self) -> Concat<L, R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L: Debug, R: Debug> Debug for Concat<L, R>

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

Formats the value using the given formatter.

impl<L, R, __Rhs> Div<__Rhs> for Concat<L, R>where Self: Expression, <Self as Expression>::SqlType: Div, <<Self as Expression>::SqlType as Div>::Rhs: SqlType + SingleValue, __Rhs: AsExpression<<<Self as Expression>::SqlType as Div>::Rhs>,

type Output = Div<Concat<L, R>, <__Rhs as AsExpression<<<Concat<L, R> as Expression>::SqlType as Div>::Rhs>>::Expression>

The resulting type after applying the / operator.

fn div(self, rhs: __Rhs) -> Self::Output

Performs the / operation.

impl<L, R, ST> Expression for Concat<L, R>where L: Expression<SqlType = ST>, R: Expression<SqlType = ST>, ST: SqlType + TypedExpressionType,

type SqlType = ST

The type that this expression represents in SQL

impl<L, R, __Rhs> Mul<__Rhs> for Concat<L, R>where Self: Expression, <Self as Expression>::SqlType: Mul, <<Self as Expression>::SqlType as Mul>::Rhs: SqlType + SingleValue, __Rhs: AsExpression<<<Self as Expression>::SqlType as Mul>::Rhs>,

type Output = Mul<Concat<L, R>, <__Rhs as AsExpression<<<Concat<L, R> as Expression>::SqlType as Mul>::Rhs>>::Expression>

The resulting type after applying the * operator.

fn mul(self, rhs: __Rhs) -> Self::Output

Performs the * operation.

impl<L, R, DB> QueryFragment<DB, ConcatWithPipesClause> for Concat<L, R>where L: QueryFragment<DB>, R: QueryFragment<DB>, DB: Backend + SqlDialect<ConcatClause = ConcatWithPipesClause>,

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

Walk over this QueryFragment for all passes.

fn to_sql(&self, out: &mut DB::QueryBuilder, backend: &DB) -> QueryResult<()>

Converts this QueryFragment to its SQL representation.

fn collect_binds<'b>( &'b self, out: &mut <DB as HasBindCollector<'b>>::BindCollector, metadata_lookup: &mut DB::MetadataLookup, backend: &'b DB ) -> QueryResult<()>

Serializes all bind parameters in this query.

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

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

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

Does walking this AST have any effect?

impl<L: QueryId, R: QueryId> QueryId for Concat<L, R>

type QueryId = Concat<<L as QueryId>::QueryId, <R as QueryId>::QueryId>

A type which uniquely represents Self in a SQL query.

const HAS_STATIC_QUERY_ID: bool = _

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

fn query_id() -> Option<TypeId>

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

impl<L, R, __Rhs> Sub<__Rhs> for Concat<L, R>where Self: Expression, <Self as Expression>::SqlType: Sub, <<Self as Expression>::SqlType as Sub>::Rhs: SqlType + SingleValue, __Rhs: AsExpression<<<Self as Expression>::SqlType as Sub>::Rhs>,

type Output = Sub<Concat<L, R>, <__Rhs as AsExpression<<<Concat<L, R> as Expression>::SqlType as Sub>::Rhs>>::Expression>

The resulting type after applying the - operator.

fn sub(self, rhs: __Rhs) -> Self::Output

Performs the - operation.

impl<L, R, __GroupByClause> ValidGrouping<__GroupByClause> for Concat<L, R>where L: ValidGrouping<__GroupByClause>, R: ValidGrouping<__GroupByClause>, L::IsAggregate: MixedAggregates<R::IsAggregate>,

type IsAggregate = <<L as ValidGrouping<__GroupByClause>>::IsAggregate as MixedAggregates<<R as ValidGrouping<__GroupByClause>>::IsAggregate>>::Output

Is this expression aggregate?

impl<L, R, QS> AppearsOnTable<QS> for Concat<L, R>where Concat<L, R>: Expression, L: AppearsOnTable<QS>, R: AppearsOnTable<QS>,

impl<L: Copy, R: Copy> Copy for Concat<L, R>

impl<L, R, QS> SelectableExpression<QS> for Concat<L, R>where Concat<L, R>: AppearsOnTable<QS>, L: SelectableExpression<QS>, R: SelectableExpression<QS>,