Struct diesel::expression::SqlLiteral

pub struct SqlLiteral<ST, T = Empty> { /* private fields */ }

Returned by the sql() function.

Implementations

impl<ST, T> SqlLiteral<ST, T> where
    ST: TypedExpressionType, 

pub fn bind<BindST, U>(self, bind_value: U) -> UncheckedBind<Self, U::Expression> where
    BindST: SqlType + TypedExpressionType,
    U: AsExpression<BindST>, 

Bind a value for use with this SQL query.

Safety

This function should be used with care, as Diesel cannot validate that the value is of the right type nor can it validate that you have passed the correct number of parameters.

Examples

let seans_id = users
    .select(id)
    .filter(sql::<Bool>("name = ").bind::<Text, _>("Sean"))
    .get_result(connection);
assert_eq!(Ok(1), seans_id);

let tess_id = sql::<Integer>("SELECT id FROM users WHERE name = ")
    .bind::<Text, _>("Tess")
    .get_result(connection);
assert_eq!(Ok(2), tess_id);

Multiple Bind Params

let query = users
    .select(name)
    .filter(
        sql::<Bool>("id > ")
        .bind::<Integer,_>(1)
        .sql(" AND name <> ")
        .bind::<Text, _>("Ryan")
    )
    .get_results(connection);
let expected = vec!["Tess".to_string()];
assert_eq!(Ok(expected), query);

pub fn sql(self, sql: &str) -> SqlLiteral<ST, Self>

Use literal SQL in the query builder

This function is intended for use when you need a small bit of raw SQL in your query. If you want to write the entire query using raw SQL, use sql_query instead.

Safety

This function should be used with care, as Diesel cannot validate that the value is of the right type nor can it validate that you have passed the correct number of parameters.

Examples

let query = users
    .select(name)
    .filter(
        sql::<Bool>("id > 1")
        .sql(" AND name <> 'Ryan'")
    )
    .get_results(connection);
let expected = vec!["Tess".to_string()];
assert_eq!(Ok(expected), query);

Trait Implementations

impl<ST, T, __Rhs> Add<__Rhs> for SqlLiteral<ST, T> where
    Self: Expression,
    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<SqlLiteral<ST, T>, <__Rhs as AsExpression<<<SqlLiteral<ST, T> 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<ST: Clone, T: Clone> Clone for SqlLiteral<ST, T>

fn clone(&self) -> SqlLiteral<ST, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<ST: Debug, T: Debug> Debug for SqlLiteral<ST, T>

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

Formats the value using the given formatter.

impl<ST, T, __Rhs> Div<__Rhs> for SqlLiteral<ST, T> where
    Self: Expression,
    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<SqlLiteral<ST, T>, <__Rhs as AsExpression<<<SqlLiteral<ST, T> 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<ST, T> Expression for SqlLiteral<ST, T> where
    ST: TypedExpressionType, 

type SqlType = ST

The type that this expression represents in SQL

impl<ST, T, __Rhs> Mul<__Rhs> for SqlLiteral<ST, T> where
    Self: Expression,
    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<SqlLiteral<ST, T>, <__Rhs as AsExpression<<<SqlLiteral<ST, T> 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<ST, T> Query for SqlLiteral<ST, T> where
    Self: Expression, 

type SqlType = ST

The SQL type that this query represents.

impl<ST, T> QueryId for SqlLiteral<ST, T>

type QueryId = ()

A type which uniquely represents Self in a SQL query.

const HAS_STATIC_QUERY_ID: bool = false

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<ST, T, Conn> RunQueryDsl<Conn> for SqlLiteral<ST, T>

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

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

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

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

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

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

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

Runs the command, and returns the affected row.

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

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

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

Attempts to load a single record.

impl<ST, T, __Rhs> Sub<__Rhs> for SqlLiteral<ST, T> where
    Self: Expression,
    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<SqlLiteral<ST, T>, <__Rhs as AsExpression<<<SqlLiteral<ST, T> 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<ST, T, GB> ValidGrouping<GB> for SqlLiteral<ST, T>

type IsAggregate = Never

Is this expression aggregate?

impl<QS, ST, T> AppearsOnTable<QS> for SqlLiteral<ST, T> where
    Self: Expression, 

impl<QS, ST, T> SelectableExpression<QS> for SqlLiteral<ST, T> where
    Self: Expression,