Creating Diesel.rs queries with a dynamic number of .and()’s

by

The first thing you need to do is look at the complete error message:

error[E0308]: mismatched types
  --> src/main.rs:23:13
   |
23 |     inner = inner.and(author.like(format!("%{}%", authors[2])));//<2>
   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected struct `diesel::expression::operators::Like`, found struct `diesel::expression::operators::And`
   |
   = note: expected type `diesel::expression::operators::And<diesel::expression::operators::Like<_, _>, _>`
              found type `diesel::expression::operators::And<diesel::expression::operators::And<diesel::expression::operators::Like<_, _>, diesel::expression::operators::Like<schema::ebook::columns::author, diesel::expression::bound::Bound<diesel::sql_types::Text, std::string::String>>>, _>`

It’s long, but that’s because it’s fully qualified. Lets shorten the last part a bit:

expected type `And<Like<_, _>, _>`
   found type `And<And<Like<_, _>, Like<author, Bound<Text, String>>>, _>`

If you review the documentation for and, you’ll see that every call to and consumes the receiver and returns a brand new type — And:

fn and<T: AsExpression<Bool>>(self, other: T) -> And<Self, T::Expression>

This is the core of Diesel’s ability to generate strongly-typed SQL expressions with no run-time overhead. All of the work is delegated to the type system. In fact, the creator of Diesel has an entire talk where he shows how far Diesel pushes the type system and what benefits it has.

Turning back to your question, it’s impossible to store an And<_, _> in the same location as an And<And<_, _>, _> because they will have different sizes and are in fact different types. At the root, this is the same as trying to store an integer in a boolean.

In fact, there’s no way to know what concrete type you need because you don’t even know how many conditions you will have — it depends on the size of the vector.

In this case, we have to give up static dispatch and move to dynamic dispatch via a trait object. Diesel has a specific trait for this case (which also has good examples): BoxableExpression.

The remaining piece is to convert your authors to like expressions and combine them. We need a base case, however, for when authors is empty. We construct a trivially true statement (author = author) for that.

#[macro_use]
extern crate diesel;

use diesel::SqliteConnection;
use diesel::prelude::*;
use diesel::sql_types::Bool;

mod schema {
    table! {
        ebook (id) {
            id -> Int4,
            author -> Text,
        }
    }
}

fn get_books(authors: Vec<String>, connection: SqliteConnection) {
    use schema::ebook::dsl::*;

    let always_true = Box::new(author.eq(author));
    let query: Box<BoxableExpression<schema::ebook::table, _, SqlType = Bool>> = authors
        .into_iter()
        .map(|name| author.like(format!("%{}%", name)))
        .fold(always_true, |query, item| {
            Box::new(query.and(item))
        });

    ebook
        .filter(query)
        .load::<(i32, String)>(&connection)
        .expect("Error loading ebook");
}

fn main() {}

I also wouldn’t be surprised if there wasn’t a better SQL way of doing this. It appears that PostgreSQL has the WHERE col LIKE ANY( subselect ) and WHERE col LIKE ALL( subselect ) forms, for example.

More Related Contents:

  1. Return local String as a slice (&str)
  2. What is the difference between iter and into_iter?
  3. How does for syntax differ from a regular lifetime bound?
  4. How to get a reference to a concrete type from a trait object?
  5. How do I return a reference to something inside a RefCell without breaking encapsulation?
  6. Conditionally iterate over one of several possible iterators
  7. Why is this match pattern unreachable when using non-literal patterns?
  8. Is there any way to create a type alias for multiple traits?
  9. What’s an idiomatic way to print an iterator separated by spaces in Rust?
  10. What are move semantics in Rust?
  11. println! error: expected a literal / format argument must be a string literal
  12. How do I return an instance of a trait from a method?
  13. “borrowed value does not live long enough” seems to blame the wrong thing
  14. Weird behaviour when using read_line in a loop
  15. Is it possible to make a type only movable and not copyable?
  16. How do I call a function through a member variable?
  17. Why are Rust executables so huge?
  18. How do you pass a Rust function as a parameter?
  19. What do I have to do to solve a “use of moved value” error?
  20. How do I implement a trait with a generic method?
  21. How do I use conditional compilation with `cfg` and Cargo?
  22. When I can use either Cell or RefCell, which should I choose?
  23. Can I take a byte array and deserialize it into a struct?
  24. How do I create a Rust callback function to pass to a FFI function?
  25. What is an auto trait in Rust?
  26. How do I convert a usize to a u32 using TryFrom?
  27. Borrow pointer errors recursively traversing tree [duplicate]
  28. How can I borrow from a HashMap to read and write at the same time?
  29. Why do I get “does not live long enough” in a return value?
  30. Why does the compiler not complain that an iterator moved to a for loop is immutable?

Leave a Comment