Can Selectable generate a dynamic SelectExpression?

[RossRogers]

Backend

PostgreSQL

Diesel version

2.3.2

Diesel Features

postgres

Operating System Version

No response

Third party libraries

No response

What do you want to do?

Trait Selectable allows generating a select expression from a struct. Is it possible to make the select expression dynamic at runtime?

To tweak the example in the docs, I'd like to do something like:

struct User {
    id: bool // <--- If true, then field is selected
    name: bool  // <--- If true, then field is selected
}

impl<DB> Selectable<DB> for User
where
    DB: Backend,
{
    type SelectExpression = (Option<users::id>, Option<users::name>);

    fn construct_selection(&self) -> Self::SelectExpression {
        return (
            if (self.id) { Some(users::id) } else {None},
            if (self.name) { Some(users::name)} else { None }
    }
}

This clearly doesn't work, not least of which:

 the trait `diesel::Expression` is not implemented for `(Option<columns::id>, Option<columns::name>)

Alternatively, can this be accomplished by stuffing the select with null values somehow?

    type SelectExpression = (Nullable<users::id>, Nullable<users::name>);

    fn construct_selection(&self) -> Self::SelectExpression {
        return (
            if (self.id) { users::id } else { ??? },
            if (self.name) { users::name} else { ??? }
    }

Compile time error

No response

What code do you already have?

No response

Additional details

No response

Checklist

• I have already looked over the issue tracker and the discussion forum for similar possible closed issues.

[weiznich]

It is certainly possible to return a "dynamic" value from the selectable trait. The same rules as everywhere in diesel apply here as well, you would need to use something like BoxableExpression to have a common return type. Also you need to ensure that the query always returns the same set of sql types. That can be achieved by making the relevant fields nullable (via NullableExpressionMethods::nullable and selecting a literal null value as alternative (via IntoSql::into_sql.

Now to the actual problem that you will face there: Selectable::construct_selection is a static method, so you cannot pass in any information about what should be dynamic. Using this trait is likely the wrong approach for the problem you are trying to solve. If you share more information about the actual problem it should be possible to give additional advice. Otherwise: Everything described above also works outside of selectable by manually constructing the select clause yourself.

[RossRogers]

@weiznich ,

The goal is to be able to have a selection configuration that is a simple JSON-mappable struct like:

struct SelectedUserFields {
    id: bool,
    name: bool,
}

and then to select these fields from the underlying table and return a struct like:

#[derive(Serialize)]
struct OptionalUser {
    id: Option<i32>,
    name: Option<String>
}

I've been trying to do what I think you're suggesting with various incantations along these lines:

use diesel::*;
use diesel::backend::Backend;
use diesel::prelude::{Queryable, Selectable};
use diesel::sql_types::{Nullable, Integer};
use diesel::dsl;
use diesel::expression::ValidGrouping;
use diesel::sql_types::Text;

type DB = diesel::pg::Pg;

diesel::table! {
    users (id) {
        id -> Int4,
        name -> Text,
    }
}
#[derive(Queryable, PartialEq, Debug)]
struct User {
    id: i32,
    name: String,
}


struct SelectedUserFields {
    id: bool,
    name: bool,
}


impl SelectedUserFields {


    fn selection<GB>(
        &self
    ) -> Box<
        dyn BoxableExpression<
            users::table,
            DB,
            GB,
            SqlType = (Nullable<Integer>, Nullable<Text>),
        >
    >
    {
        (
            if self.id {
                Box::new(users::id.nullable())
            } else {
                Box::new("null".into_sql::<Nullable<Integer>>())
            },
            if self.name {
                Box::new(users::name.nullable())
            } else {
                Box::new("null".into_sql::<Nullable<Text>>())
            },

        )
    }
}

fn main() {
    let selected_fields = SelectedUserFields {
        id: true,
        name: false,
    };
    let selected_susers = users::table
        .select(selected_fields.selection());
}

[weiznich]

@RossRogers If you still want to know something you might want to formulate an actual question, including what happens if you try your code. Don't expect others to guess what you might want to know.