Function select

pub async fn select<T: SqlQuery + SqlParams, R, F>(
    pool: &Pool,
    entity: T,
    to_model: F,
) -> Result<R, Error>
where
    F: Fn(&Row) -> Result<R, Error>,

select

Deadpool bağlantı havuzunu kullanarak özel bir model dönüştürücü fonksiyon ile veritabanından bir kayıt seçer.

Parametreler

• pool: Deadpool bağlantı havuzu
• entity: Sorgu parametrelerini içeren veri nesnesi (SqlQuery ve SqlParams trait’lerini uygulamalıdır)
• to_model: Satırı modele dönüştüren fonksiyon

Dönüş Değeri

• Result<R, Error>: Başarılı olursa, dönüştürülen modeli döndürür; başarısız olursa, Error döndürür

Kullanım Örneği

use deadpool_postgres::{Config, Runtime, Pool};
use tokio_postgres::{NoTls, Error, Row};
use parsql::tokio_postgres::pool_crud_ops::select;
 
#[derive(Queryable, SqlParams)]
#[table("users")]
#[where_clause("id = $")]
pub struct UserQuery {
    pub id: i32,
}

pub struct UserModel {
    pub id: i32,
    pub name: String,
    pub email: String,
    pub is_active: bool,
}

impl UserQuery {
    pub fn new(id: i32) -> Self {
        Self { id }
    }
}

fn row_to_user(row: &Row) -> Result<UserModel, Error> {
    Ok(UserModel {
        id: row.try_get("id")?,
        name: row.try_get("name")?,
        email: row.try_get("email")?,
        is_active: row.try_get::<_, i16>("state")? == 1,
    })
}
 
#[tokio::main]
async fn main() -> Result<(), Error> {
    let mut cfg = Config::new();
    cfg.host = Some("localhost".to_string());
    cfg.dbname = Some("test".to_string());
     
    let pool = cfg.create_pool(Some(Runtime::Tokio1), NoTls).unwrap();

    let query = UserQuery::new(1);
    let user = select(&pool, query, row_to_user).await?;
     
    println!("User: {:?}", user);
    Ok(())
}