//#[macro_use] define in 'root crate' or 'mod.rs' or 'main.rs'
#[macro_use]
extern crate rbatis;
extern crate rbdc;
use rbatis::{impl_insert,impl_insert,impl_update,impl_delete,impl_select_page};
use rbdc::datetime::FastDateTime;
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct BizActivity {
  pub id: Option<String>,
  pub name: Option<String>,
  pub pc_link: Option<String>,
  pub h5_link: Option<String>,
  pub pc_banner_img: Option<String>,
  pub h5_banner_img: Option<String>,
  pub sort: Option<String>,
  pub status: Option<i32>,
  pub remark: Option<String>,
  pub create_time: Option<FastDateTime>,
  pub version: Option<i64>,
  pub delete_flag: Option<i32>,
}
crud!(BizActivity{});//crud = insert+select_by_column+update_by_column+delete_by_column

impl_select!(BizActivity{select_all_by_id(id:&str,name:&str) => "`where id = #{id} and name = #{name}`"});
impl_select!(BizActivity{select_by_id(id:String) -> Option => "`where id = #{id} limit 1`"});
impl_update!(BizActivity{update_by_name(name:&str) => "`where id = 1`"});
impl_delete!(BizActivity {delete_by_name(name:&str) => "`where name= '2'`"});
impl_select_page!(BizActivity{select_page(name:&str) => "`where name != #{name}`"});

#[tokio::main]
async fn main() {
  /// enable log crate to show sql logs
  fast_log::init(fast_log::Config::new().console());
  /// initialize rbatis. also you can call rb.clone(). this is  an Arc point
  let rb = Rbatis::new();
  /// connect to database  
  // sqlite 
  rb.link(SqliteDriver {},"sqlite://target/sqlite.db").await.unwrap();
  // mysql 
  // rb.link(MysqlDriver{},"mysql://root:123456@localhost:3306/test").await.unwrap();
  // postgresql 
  // rb.link(PgDriver{},"postgres://postgres:123456@localhost:5432/postgres").await.unwrap();
  // mssql/sqlserver
  // rb.link(MssqlDriver{},"jdbc:sqlserver://localhost:1433;User=SA;Password={TestPass!123456};Database=test").await.unwrap();
  
  let activity =  BizActivity {
    id: Some("2".into()),
    name: Some("2".into()),
    pc_link: Some("2".into()),
    h5_link: Some("2".into()),
    pc_banner_img: None,
    h5_banner_img: None,
    sort: None,
    status: Some(2),
    remark: Some("2".into()),
    create_time: Some(FastDateTime::now()),
    version: Some(1),
    delete_flag: Some(1),
  };
  let data = BizActivity::insert(&mut rb, &activity).await;
  println!("insert = {:?}", data);

  let data = BizActivity::select_all_by_id(&mut rb, "1", "1").await;
  println!("select_all_by_id = {:?}", data);

  let data = BizActivity::select_by_id(&mut rb, "1".to_string()).await;
  println!("select_by_id = {:?}", data);

  let data = BizActivity::update_by_column(&mut rb, &activity, "id").await;
  println!("update_by_column = {:?}", data);

  let data = BizActivity::update_by_name(&mut rb, &activity, "test").await;
  println!("update_by_name = {:?}", data);

  let data = BizActivity::delete_by_column(&mut rb, "id", &"2".into()).await;
  println!("delete_by_column = {:?}", data);

  let data = BizActivity::delete_by_name(&mut rb, "2").await;
  println!("delete_by_column = {:?}", data);

  let data = BizActivity::select_page(&mut rb, &PageRequest::new(1, 10), "2").await;
  println!("select_page = {:?}", data);
}
///...more usage,see crud.rs

    #[py_sql("select * from biz_activity where delete_flag = 0
                  if name != '':
                    `and name=#{name}`")]
    async fn py_sql_tx(rb: &Rbatis, tx_id: &String, name: &str) -> Vec<BizActivity> { impled!() }

    ///select page must have  '?:&PageRequest' arg and return 'Page<?>'
    #[html_sql("example/example.html")]
    async fn select_by_condition(rb: &mut dyn Executor, page_req: &PageRequest, name: &str) -> Page<BizActivity> { impled!() }

use once_cell::sync::Lazy;
pub static RB:Lazy<Rbatis> = Lazy::new(||Rbatis::new());

/// Macro generates execution logic based on method definition, similar to @select dynamic SQL of Java/Mybatis
/// RB is the name referenced locally by Rbatis, for example DAO ::RB, com:: XXX ::RB... Can be
/// The second parameter is the standard driver SQL. Note that the corresponding database parameter mysql is? , pg is $1...
/// macro auto edit method to  'pub async fn select(name: &str) -> rbatis::core::Result<BizActivity> {}'
///
#[sql("select * from biz_activity where id = ?")]
pub async fn select(rb: &Rbatis,name: &str) -> BizActivity {}
//or： pub async fn select(name: &str) -> rbatis::core::Result<BizActivity> {}

#[tokio::test]
pub async fn test_macro() {
    fast_log::init(fast_log::Config::new().console());
    RB.link("mysql://root:123456@localhost:3306/test").await.unwrap();
    let a = select(&RB,"1").await.unwrap();
    println!("{:?}", a);
}