在 Rust Diesel 中进行原始 sql 查询

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)
    }
}