sqlx-model-core 0.0.1-beta.1

use crate::{TableName};
pub async fn test_db()->sqlx::Pool<sqlx::MySql>{
    use std::str::FromStr;
    let table_prefix = "yaf_".to_string();
    TableName::set_prefix(table_prefix);
    let database_url = "mysql://root:@127.0.0.1/test";
    let option =sqlx::mysql::MySqlConnectOptions::from_str(&database_url)
        .unwrap();
    sqlx::pool::PoolOptions::<sqlx::MySql>::new()
        .max_connections(5)
        .connect_with(
            option.to_owned()
        )
        .await
        .unwrap()
}


#[tokio::test]
async fn curdtest(){
    use crate::{Delete, Insert, ModelTableName, Select, Update};
    use sqlx::FromRow;

    let db=crate::test::test_db().await;

    #[derive(FromRow,Clone,Debug)]
    struct UserModel {
        id: u32,
        nickname: String,
        gender: u8,
        headimg: String,
        password_id: u32,
    }

    crate::model_table_value_bind_define!(UserModel,"user",{id,nickname,gender,headimg,password_id},{id});
    crate::model_table_option_define!(UserModel,UserModelOption,{
        id:  u32,
        nickname: String,
        gender: u8,
        headimg: String,
        password_id:u32
    });


    //insert test

    let nike_name="new insert".to_string();
    let gender=1;
    let userinsert=crate::model_option_var!(UserModelOption,{
        nickname:nike_name,
        gender:gender,
    });
    let i1=Insert::<sqlx::MySql,UserModel,_>::new(userinsert).execute(&db).await.unwrap();
    assert!(i1.last_insert_id()>0);


    let nike_name="new vec insert".to_string();
    let gender=1;
    let userinsert=vec![crate::model_option_var!(UserModelOption,{
        nickname:nike_name,
        gender:gender,
    })];
    let i2=Insert::<sqlx::MySql,UserModel,_>::new_vec(userinsert).execute(&db).await.unwrap();
    assert!(i2.last_insert_id()>0);


    let nickname="model insert".to_string();
    let i3=Insert::<sqlx::MySql,UserModel,_>::model(&UserModel{
        id:i2.last_insert_id() as u32+1,
        nickname:nickname.clone(),
        gender:1,
        headimg:"ddd".to_string(),
        password_id:1,
    }).execute(&db).await.unwrap();
    assert_eq!(i3.rows_affected(),1);

    let vec=vec![
        UserModel{
            id:i3.last_insert_id() as u32+1,
            nickname:"model vec".to_string(),
            gender:1,
            headimg:"ddd".to_string(),
            password_id:1,
        }
    ];
    let i4=Insert::<sqlx::MySql,UserModel,_>::model_vec(&vec).execute(&db).await.unwrap();
    assert_eq!(i4.rows_affected(),1);

    //update

    let nike_name="change 1".to_string();
    let userchange=crate::model_option_var!(UserModelOption,{
        headimg:nike_name,
    });
    let update=Update::<sqlx::MySql,UserModel,_>::new(userchange);
    let update=update.execute_by_where("id=?",|mut b,_|{
        b=b.bind(i1.last_insert_id());
        b
    },&db).await.unwrap();
    assert_eq!(update.rows_affected(),1);


    let tmp=&UserModel{
        id:1,
        nickname:"model vec".to_string(),
        gender:2,
        headimg:"change 2".to_string(),
        password_id:1,
    };
    let update=Update::model(tmp, None);
    let update=update.execute_by_scalar_pk(i2.last_insert_id(),&db).await.unwrap();
    assert_eq!(update.rows_affected(),1);


    let select=Select::type_new::<UserModel>();
    let user=select.fetch_one_by_where::<UserModel,_>("id=?",|mut b,_|{
        b=b.bind(i3.last_insert_id());
        b
    }, &db).await.unwrap();

    let nike_name="change 3".to_string();
    let userchange=crate::model_option_var!(UserModelOption,{
        headimg:nike_name,
    });
    let update=Update::<_,UserModel,_>::new(userchange);
    let update=update.execute_by_pk(&user,&db).await.unwrap();
    assert_eq!(update.rows_affected(),1);

    //select 
    let select=Select::type_new::<UserModel>();
    let user=select.fetch_one_by_scalar_pk::<UserModel,_>(1, &db).await.unwrap();
    assert_eq!(user.nickname,"model vec".to_string());

    let user=select.reload::<UserModel>(&user, &db).await.unwrap();
    assert_eq!(user.nickname,"model vec".to_string());
    

    let (sql,bind_res)=crate::model_sql_bind!(
        sqlx::MySql,
        r#"nickname=:nickname"#,
        [":nickname"]
    );
    let user=select.fetch_one_by_where::<UserModel,_>(sql.as_str(),|mut b,_|{
        crate::model_sql_bind_match!(bind_res,{
            ":nickname":{
                b=b.bind(nickname.clone());
            }
        });
        b
    }, &db).await.unwrap();
    assert_eq!(user.nickname,nickname);

    let tuser=select.fetch_one_by_sql::<UserModel,_,_>(|select|{
        format!("select {} from {} where id in (?)",select.table_field,select.table_name)
    },|mut b,_|{
        b=b.bind(1);
        b
    }, &db).await.unwrap();
    assert_eq!(tuser.id,1);


    let tuser=select.fetch_one_scalar_by_sql::<String,_,_>(|select|{
        format!("select nickname from {} where id in (?)",select.table_name)
    },|mut b,_|{
        b=b.bind(1);
        b
    },&db).await.unwrap();
    assert_eq!(tuser,"model vec".to_string());


    //delete
    let detete=Delete::new(UserModel::table_name())
        .execute_by_pk(&user, &db)
        .await.unwrap();
    assert_eq!(detete.rows_affected(),1);

    let detete=Delete::new(UserModel::table_name())
        .execute_by_scalar_pk::<UserModel,_>(1, &db)
        .await.unwrap();
    assert_eq!(detete.rows_affected(),1);

}