Making a raw sql-query in Rust Diesel - postgresql

Question

I need to query a function in Postgresql (14) using diesel. I already have queries that works on tables and views. This works, a view in this case.
schema.rs:
table! {
latest_readings {
measurement_time_default -> Timestamptz,
id -> Integer,
data -> Jsonb,
}
}
models.rs:
#[derive(Serialize, Queryable)]
pub struct LatestReading {
#[diesel(deserialize_as = "MyDateTimeWrapper")]
pub measurement_time_default: DateTime<Local>,
pub id: i32,
pub data: serde_json::Value,
}
controller.rs:
pub async fn get_readings(db: web::Data<Pool>) -> Result<HttpResponse, Error> {
Ok(web::block(move || db_get_readings(db))
.await
.map(|reading| HttpResponse::Ok().json(reading))
.map_err(|_| HttpResponse::InternalServerError())?)
}
fn db_get_readings(pool: web::Data<Pool>) -> Result<Vec<LatestReading>, diesel::result::Error> {
let conn = pool.get().unwrap();
latest_readings.load::<LatestReading>(&conn)
}
This won't compile. The part that call the postgresql-function.
schema.rs:
table! {
measurements_single_location_function {
id -> Integer,
name -> Text,
latitude -> Numeric,
longitude -> Numeric,
measurement_time_default -> Timestamptz,
measurements -> Jsonb,
}
}
models.rs:
#[derive(Serialize, Queryable, QueryableByName)]
#[table_name = "measurements_single_location_function"]
pub struct MeasurementsSingleLocation {
pub id: i32,
pub name: String,
pub latitude: BigDecimal,
pub longitude: BigDecimal,
#[diesel(deserialize_as = "MyDateTimeWrapper")]
pub measurement_time_default: DateTime<Local>,
pub measurements: serde_json::Value,
}
DB-query in controllers.rs:
fn db_get_measurements_single_location(
pool: web::Data<Pool>,
location_id: i32,
rows: i32,
) -> QueryResult<Vec<MeasurementsSingleLocation>> {
let conn = pool.get().unwrap(); // Error on next line
let result: QueryResult<Vec<MeasurementsSingleLocation>> =
sql_query("select * from measurements_single_location_function(1,10)")
.load::<MeasurementsSingleLocation>(&conn);
return result;
}
The compile-error:
Compiling weather_rest v0.1.0 (/Users/claus/devel/rust/vegvesen/weather_rest)
error[E0277]: the trait bound `SqlQuery: LoadQuery<_, MeasurementsSingleLocation>` is not satisfied
--> src/controller.rs:141:14
|
141 | .load::<MeasurementsSingleLocation>(&conn);
| ^^^^ the trait `LoadQuery<_, MeasurementsSingleLocation>` is not implemented for `SqlQuery`
|
= help: the following implementations were found:
<SqlQuery as LoadQuery<Conn, T>>
note: required by a bound in `load`
--> /Users/claus/.cargo/registry/src/github.com-1ecc6299db9ec823/diesel-1.4.6/src/query_dsl/mod.rs:1238:15
|
1238 | Self: LoadQuery<Conn, U>,
| ^^^^^^^^^^^^^^^^^^ required by this bound in `load`
I am not able to see what I am missing here.
Cargo.toml:
diesel = { version = "1.4.6", features = ["postgres", "uuidv07", "r2d2", "chrono", "numeric", "serde_json"] }

Answer 1

I recently wrote a backend-service for another project using this excellent example as a template. I applied the same structure to this and it now compiles.
schema.rs:
table! {
measurements_single_location_function {
id -> Integer,
name -> Text,
latitude -> Text,
longitude -> Text,
measurement_time_default -> Timestamptz,
measurements -> Jsonb,
}
}
routes.rs:
#[get("/measurements_single_location/{id}/{rows}")]
async fn measurements_single_location(path: web::Path<(i32, i32)>) -> Result<HttpResponse, CustomError> {
let (id, rows) = path.into_inner();
let m = MeasurementsSingleLocation::measurements_single_location(id, rows)?;
Ok(HttpResponse::Ok().json(m))
}
pub fn init_routes(config: &mut web::ServiceConfig) {
config.service(measurements_single_location);
}
models.rs:
#[derive(Serialize, QueryableByName)]
#[table_name = "measurements_single_location_function"]
pub struct MeasurementsSingleLocation {
pub id: i32,
pub name: String,
pub latitude: String,
pub longitude: String,
pub measurement_time_default: NaiveDateTime,
pub measurements: serde_json::Value,
}
impl MeasurementsSingleLocation {
pub fn measurements_single_location(id: i32, rows: i32) -> Result<Vec<MeasurementsSingleLocation>, CustomError> {
let q = "select * from measurements_single_location_function($1,$2)";
let mut conn = db::connection()?;
let m= diesel::sql_query(q)
.bind::<Integer, _>(id)
.bind::<Integer, _>(rows)
.get_results(&mut conn)?;
Ok(m)
}
}