# Struct diesel::expression::Concat

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

Available on

**crate feature**only.`i-implement-a-third-party-backend-and-opt-into-breaking-changes`

## Expand description

This type represents a string concat operator

## Fields (Non-exhaustive)§

## This struct is marked as 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§

source§### 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>,

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

#### 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.source§### 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>,

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

#### 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.source§### impl<L, R, ST> Expression for Concat<L, R>where
L: Expression<SqlType = ST>,
R: Expression<SqlType = ST>,
ST: SqlType + TypedExpressionType,

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

source§### 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>,

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

#### 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.source§### impl<L, R, DB> QueryFragment<DB, ConcatWithPipesClause> for Concat<L, R>where
L: QueryFragment<DB>,
R: QueryFragment<DB>,
DB: Backend + SqlDialect<ConcatClause = ConcatWithPipesClause>,

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

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

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

Walk over this

`QueryFragment`

for all passes. Read moresource§#### fn to_sql(&self, out: &mut DB::QueryBuilder, backend: &DB) -> QueryResult<()>

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

Available on

**crate feature**only.`i-implement-a-third-party-backend-and-opt-into-breaking-changes`

Converts this

`QueryFragment`

to its SQL representation. Read moresource§#### fn collect_binds<'b>(
&'b self,
out: &mut <DB as HasBindCollector<'b>>::BindCollector,
metadata_lookup: &mut DB::MetadataLookup,
backend: &'b DB
) -> QueryResult<()>

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

Available on

**crate feature**only.`i-implement-a-third-party-backend-and-opt-into-breaking-changes`

Serializes all bind parameters in this query. Read more

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

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

Available on

**crate feature**only.`i-implement-a-third-party-backend-and-opt-into-breaking-changes`

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

source§### impl<L: QueryId, R: QueryId> QueryId for Concat<L, R>

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

source§### 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>,

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

#### 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.source§### impl<L, R, __GroupByClause> ValidGrouping<__GroupByClause> for Concat<L, R>where
L: ValidGrouping<__GroupByClause>,
R: ValidGrouping<__GroupByClause>,
L::IsAggregate: MixedAggregates<R::IsAggregate>,

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

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

Is this expression aggregate? Read more

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

## Auto Trait Implementations§

### impl<L, R> RefUnwindSafe for Concat<L, R>where L: RefUnwindSafe, R: RefUnwindSafe,

### impl<L, R> Send for Concat<L, R>where L: Send, R: Send,

### impl<L, R> Sync for Concat<L, R>where L: Sync, R: Sync,

### impl<L, R> Unpin for Concat<L, R>where L: Unpin, R: Unpin,

### impl<L, R> UnwindSafe for Concat<L, R>where L: UnwindSafe, R: UnwindSafe,

## Blanket Implementations§

source§### impl<T, ST> AsExpression<ST> for Twhere
T: Expression<SqlType = ST>,
ST: SqlType + TypedExpressionType,

### impl<T, ST> AsExpression<ST> for Twhere T: Expression<SqlType = ST>, ST: SqlType + TypedExpressionType,

§#### type Expression = T

#### type Expression = T

The expression being returned

source§#### fn as_expression(self) -> T

#### fn as_expression(self) -> T

Perform the conversion

source§### impl<Conn, DB, T> ExecuteDsl<Conn, DB> for Twhere
Conn: Connection<Backend = DB>,
DB: Backend,
T: QueryFragment<DB, NotSpecialized> + QueryId,

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

source§### impl<T> IntoSql for T

### impl<T> IntoSql for T

source§#### fn into_sql<T>(self) -> AsExprOf<Self, T>where
Self: AsExpression<T> + Sized,
T: SqlType + TypedExpressionType,

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

Convert

`self`

to an expression for Diesel’s query builder. Read moresource§#### fn as_sql<'a, T>(&'a self) -> AsExprOf<&'a Self, T>where
&'a Self: AsExpression<T>,
T: SqlType + TypedExpressionType,

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

Convert

`&self`

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