Trait diesel::prelude::Queryable

source · [−]

pub trait Queryable<ST, DB>: Sized where
    DB: Backend, {
    type Row: FromStaticSqlRow<ST, DB>;

    fn build(row: Self::Row) -> Result<Self>;
}

Expand description

Trait indicating that a record can be queried from the database.

Types which implement Queryable represent the result of a SQL query. This does not necessarily mean they represent a single database table.

Diesel represents the return type of a query as a tuple. The purpose of this trait is to convert from a tuple of Rust values that have been deserialized into your struct.

This trait can be derived

Interaction with `NULL`/`Option`

Nullable types can be queried into Option. This is valid for single fields, tuples, and structures with Queryable.

With tuples and structs, the process for deserializing an Option<(A,B,C)> is to attempt to deserialize A, B and C, and if either of these return an UnexpectedNullError, the Option will be deserialized as None.
If all succeed, the Option will be deserialized as Some((a,b,c)).

Examples

Simple mapping from query to struct

If we just want to map a query to our struct, we can use derive.

#[derive(Queryable, PartialEq, Debug)]
struct User {
    id: i32,
    name: String,
}

let first_user = users.order_by(id).first(connection)?;
let expected = User { id: 1, name: "Sean".into() };
assert_eq!(expected, first_user);

Interaction with `NULL`/`Option`

Single field

table! {
    animals {
        id -> Integer,
        species -> VarChar,
        legs -> Integer,
        name -> Nullable<VarChar>,
    }
}
#[derive(Queryable, PartialEq, Debug)]
struct Animal {
    id: i32,
    name: Option<String>,
}

let all_animals = animals.select((id, name)).order_by(id).load(connection)?;
let expected = vec![Animal { id: 1, name: Some("Jack".to_owned()) }, Animal { id: 2, name: None }];
assert_eq!(expected, all_animals);

Multiple fields

#[derive(Queryable, PartialEq, Debug)]
struct UserWithPost {
    id: i32,
    post: Option<Post>,
}
#[derive(Queryable, PartialEq, Debug)]
struct Post {
    id: i32,
    title: String,
}

let all_posts = users::table
    .left_join(posts::table)
    .select((
        users::id,
        (posts::id, posts::title).nullable()
    ))
    .order_by((users::id, posts::id))
    .load(connection)?;
let expected = vec![
    UserWithPost { id: 1, post: Some(Post { id: 1, title: "My first post".to_owned() }) },
    UserWithPost { id: 1, post: Some(Post { id: 2, title: "About Rust".to_owned() }) },
    UserWithPost { id: 2, post: Some(Post { id: 3, title: "My first post too".to_owned() }) },
    UserWithPost { id: 3, post: None },
];
assert_eq!(expected, all_posts);

`deserialize_as` attribute

If we want to do additional work during deserialization, we can use deserialize_as to use a different implementation.

struct LowercaseString(String);

impl Into<String> for LowercaseString {
    fn into(self) -> String {
        self.0
    }
}

impl<DB> Queryable<Text, DB> for LowercaseString
where
    DB: Backend,
    String: FromSql<Text, DB>,
{
    type Row = String;

    fn build(s: String) -> deserialize::Result<Self> {
        Ok(LowercaseString(s.to_lowercase()))
    }
}

#[derive(Queryable, PartialEq, Debug)]
struct User {
    id: i32,
    #[diesel(deserialize_as = LowercaseString)]
    name: String,
}

let first_user = users.first(connection)?;
let expected = User { id: 1, name: "sean".into() };
assert_eq!(expected, first_user);

Manual implementation

Alternatively, we can implement the trait for our struct manually.

use schema::users;
use diesel::deserialize::{self, Queryable};

type DB = diesel::sqlite::Sqlite;

#[derive(PartialEq, Debug)]
struct User {
    id: i32,
    name: String,
}

impl Queryable<users::SqlType, DB> for User {
    type Row = (i32, String);

    fn build(row: Self::Row) -> deserialize::Result<Self> {
        Ok(User {
            id: row.0,
            name: row.1.to_lowercase(),
        })
    }
}

let first_user = users.first(connection)?;
let expected = User { id: 1, name: "sean".into() };
assert_eq!(expected, first_user);

Trait diesel::prelude::Queryable

Required Associated Types

type Row: FromStaticSqlRow<ST, DB>

Required Methods

fn build(row: Self::Row) -> Result<Self>

Implementations on Foreign Types

impl<__ST, __DB> Queryable<__ST, __DB> for [u8; 6] where __DB: Backend, __ST: SingleValue, Self: FromSql<__ST, __DB>,

type Row = [u8; 6]

fn build(row: Self::Row) -> Result<Self>

impl<__ST, __DB> Queryable<__ST, __DB> for IpNetwork where __DB: Backend, __ST: SingleValue, Self: FromSql<__ST, __DB>,

type Row = IpNetwork

fn build(row: Self::Row) -> Result<Self>

impl<T, ST> Queryable<Range<ST>, Pg> for (Bound<T>, Bound<T>) where T: FromSql<ST, Pg>,

type Row = (Bound<T>, Bound<T>)

fn build(row: Self) -> Result<Self>

impl<T0, ST0> Queryable<Record<(ST0,)>, Pg> for (T0,) where Self: FromSql<Record<(ST0,)>, Pg>,

type Row = (T0,)

fn build(row: Self::Row) -> Result<Self>

impl<T0, T1, ST0, ST1> Queryable<Record<(ST0, ST1)>, Pg> for (T0, T1) where Self: FromSql<Record<(ST0, ST1)>, Pg>,

type Row = (T0, T1)

fn build(row: Self::Row) -> Result<Self>

impl<T0, T1, T2, ST0, ST1, ST2> Queryable<Record<(ST0, ST1, ST2)>, Pg> for (T0, T1, T2) where Self: FromSql<Record<(ST0, ST1, ST2)>, Pg>,

type Row = (T0, T1, T2)

fn build(row: Self::Row) -> Result<Self>

impl<T0, T1, T2, T3, ST0, ST1, ST2, ST3> Queryable<Record<(ST0, ST1, ST2, ST3)>, Pg> for (T0, T1, T2, T3) where Self: FromSql<Record<(ST0, ST1, ST2, ST3)>, Pg>,

type Row = (T0, T1, T2, T3)

fn build(row: Self::Row) -> Result<Self>

impl<T0, T1, T2, T3, T4, ST0, ST1, ST2, ST3, ST4> Queryable<Record<(ST0, ST1, ST2, ST3, ST4)>, Pg> for (T0, T1, T2, T3, T4) where Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4)>, Pg>,

type Row = (T0, T1, T2, T3, T4)

fn build(row: Self::Row) -> Result<Self>

impl<T0, T1, T2, T3, T4, T5, ST0, ST1, ST2, ST3, ST4, ST5> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5)>, Pg> for (T0, T1, T2, T3, T4, T5) where Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5)>, Pg>,

type Row = (T0, T1, T2, T3, T4, T5)

fn build(row: Self::Row) -> Result<Self>

impl<T0, T1, T2, T3, T4, T5, T6, ST0, ST1, ST2, ST3, ST4, ST5, ST6> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6)>, Pg> for (T0, T1, T2, T3, T4, T5, T6) where Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6)>, Pg>,

type Row = (T0, T1, T2, T3, T4, T5, T6)

fn build(row: Self::Row) -> Result<Self>

impl<T0, T1, T2, T3, T4, T5, T6, T7, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7) where Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7)>, Pg>,

type Row = (T0, T1, T2, T3, T4, T5, T6, T7)

fn build(row: Self::Row) -> Result<Self>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)>, Pg>,

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8)

fn build(row: Self::Row) -> Result<Self>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9)>, Pg>,

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

fn build(row: Self::Row) -> Result<Self>

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

fn build(row: Self::Row) -> Result<Self>

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

fn build(row: Self::Row) -> Result<Self>

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

fn build(row: Self::Row) -> Result<Self>

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)

fn build(row: Self::Row) -> Result<Self>

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)

fn build(row: Self::Row) -> Result<Self>

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

fn build(row: Self::Row) -> Result<Self>

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)

fn build(row: Self::Row) -> Result<Self>

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)

fn build(row: Self::Row) -> Result<Self>

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)

fn build(row: Self::Row) -> Result<Self>

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)

fn build(row: Self::Row) -> Result<Self>

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)

fn build(row: Self::Row) -> Result<Self>

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)

fn build(row: Self::Row) -> Result<Self>

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)

fn build(row: Self::Row) -> Result<Self>

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)

fn build(row: Self::Row) -> Result<Self>

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)

fn build(row: Self::Row) -> Result<Self>

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25)

fn build(row: Self::Row) -> Result<Self>

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26)

fn build(row: Self::Row) -> Result<Self>

type Row = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27)

impl<ST, DB> Queryable<ST, DB> for [u8 ; 6] where
DB: Backend,
ST: SingleValue,
Self: FromSql<ST, DB>,

type Row = [u8 ; 6]

impl<ST, DB> Queryable<ST, DB> for IpNetwork where
DB: Backend,
ST: SingleValue,
Self: FromSql<ST, DB>,

impl<T, ST> Queryable<Range<ST>, Pg> for (Bound<T>, Bound<T>) where
T: FromSql<ST, Pg>,

impl<T0, ST0> Queryable<Record<(ST0,)>, Pg> for (T0,) where
Self: FromSql<Record<(ST0,)>, Pg>,

impl<T0, T1, ST0, ST1> Queryable<Record<(ST0, ST1)>, Pg> for (T0, T1) where
Self: FromSql<Record<(ST0, ST1)>, Pg>,

impl<T0, T1, T2, ST0, ST1, ST2> Queryable<Record<(ST0, ST1, ST2)>, Pg> for (T0, T1, T2) where
Self: FromSql<Record<(ST0, ST1, ST2)>, Pg>,

impl<T0, T1, T2, T3, ST0, ST1, ST2, ST3> Queryable<Record<(ST0, ST1, ST2, ST3)>, Pg> for (T0, T1, T2, T3) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3)>, Pg>,

impl<T0, T1, T2, T3, T4, ST0, ST1, ST2, ST3, ST4> Queryable<Record<(ST0, ST1, ST2, ST3, ST4)>, Pg> for (T0, T1, T2, T3, T4) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4)>, Pg>,

impl<T0, T1, T2, T3, T4, T5, ST0, ST1, ST2, ST3, ST4, ST5> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5)>, Pg> for (T0, T1, T2, T3, T4, T5) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5)>, Pg>,

impl<T0, T1, T2, T3, T4, T5, T6, ST0, ST1, ST2, ST3, ST4, ST5, ST6> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6)>, Pg> for (T0, T1, T2, T3, T4, T5, T6) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6)>, Pg>,

impl<T0, T1, T2, T3, T4, T5, T6, T7, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7)>, Pg>,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)>, Pg>,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9> Queryable<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9)>, Pg> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
Self: FromSql<Record<(ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9)>, Pg>,

impl<ST, DB> Queryable<ST, DB> for Uuid where
DB: Backend,
ST: SingleValue,
Self: FromSql<ST, DB>,

impl<ST, DB> Queryable<ST, DB> for SystemTime where
DB: Backend,
ST: SingleValue,
Self: FromSql<ST, DB>,

impl<ST, DB> Queryable<ST, DB> for NaiveDate where
DB: Backend,
ST: SingleValue,
Self: FromSql<ST, DB>,

impl<ST, DB> Queryable<ST, DB> for NaiveTime where
DB: Backend,
ST: SingleValue,
Self: FromSql<ST, DB>,

impl<ST, DB> Queryable<ST, DB> for NaiveDateTime where
DB: Backend,
ST: SingleValue,
Self: FromSql<ST, DB>,

impl<ST, DB, Tz: TimeZone> Queryable<ST, DB> for DateTime<Tz> where
DB: Backend,
ST: SingleValue,
Self: FromSql<ST, DB>,

impl<ST, DB> Queryable<ST, DB> for BigDecimal where
DB: Backend,
ST: SingleValue,
Self: FromSql<ST, DB>,

impl<ST, DB> Queryable<ST, DB> for Value where
DB: Backend,
ST: SingleValue,
Self: FromSql<ST, DB>,