che-orm 0.4.0

Typed SQLite and PostgreSQL ORM for che-rest applications
Documentation
use che_orm::{ColumnType, DatabaseValue, Model, PostgresDialect, SqlCompiler, SqliteDialect};

#[derive(Debug, Model)]
#[orm(table = "balances")]
struct Balance {
    #[orm(primary_key)]
    id: i64,
    amount: f64,
    optional_amount: Option<f64>,
}

#[test]
fn real_schema_and_sql_keep_fractional_values() {
    let schema = Balance::schema();
    assert_eq!(schema.columns[1].column_type, ColumnType::Real);
    assert!(schema.columns[2].nullable);
    assert!(
        SqlCompiler::<SqliteDialect>::compile_schema(&schema)
            .table
            .contains("amount REAL")
    );
    assert!(
        SqlCompiler::<PostgresDialect>::compile_schema(&schema)
            .table
            .contains(r#""amount" DOUBLE PRECISION"#)
    );
    let ast = Balance::insert()
        .set(Balance::AMOUNT, 12.75)
        .into_ast()
        .unwrap();
    assert_eq!(
        SqlCompiler::<SqliteDialect>::compile(&ast).params,
        vec![DatabaseValue::Real(12.75)]
    );
}

#[cfg(feature = "sqlite")]
#[tokio::test]
async fn real_fields_round_trip_and_filter_numerically() {
    let db = che_orm::Database::connect_in_memory().await.unwrap();
    db.create_table::<Balance>().await.unwrap();
    let result = db
        .insert(&Balance {
            id: 0,
            amount: 12.75,
            optional_amount: Some(-0.125),
        })
        .await
        .unwrap();
    let id = result.last_insert_rowid.unwrap();
    let row = db.get::<Balance>(id).await.unwrap().unwrap();
    assert_eq!(row.amount, 12.75);
    assert_eq!(row.optional_amount, Some(-0.125));
    let rows = db
        .fetch_all(Balance::query().filter(Balance::AMOUNT.gt(12.5)))
        .await
        .unwrap();
    assert_eq!(rows.len(), 1);
    db.execute(
        Balance::update()
            .set(Balance::AMOUNT, 0.25)
            .set(Balance::OPTIONAL_AMOUNT, None::<f64>)
            .filter(Balance::ID.eq(id))
            .into_ast()
            .unwrap(),
    )
    .await
    .unwrap();
    let row = db.get::<Balance>(id).await.unwrap().unwrap();
    assert_eq!(row.amount, 0.25);
    assert_eq!(row.optional_amount, None);
}