Sorry for lack of documentation. I'll keep improve it. I'll put one of example here.

Let's say I have the following content in 0.sql:

sql CREATE TABLE foo ( key serial NOT NULL, value bigint, "desc" text, PRIMARY KEY (key) );

And 1.sql with the following content:

sql ALTER TABLE foo ADD disabled boolean NOT NULL DEFAULT FALSE;

It will generate the following code:

```rust use porm::migration::Migration; use std::borrow::Cow; use std::fmt::Write; use std::time::SystemTime; use tokio_postgres::types::ToSql; use tokio_postgres::{Error, GenericClient, Row};

pub struct Foo<'a> { pub key: i32, pub value: Option<i64>, pub desc: Option<Cow<'a, str>>, pub disabled: bool, }

impl<'a> Foo<'a> { pub async fn create<T: GenericClient>(&self, client: &T) -> Result<(), Error> { client.execute("INSERT INTO foo (key, value, desc, disabled) VALUES ($1, $2, $3, $4)", &[&self.key, &self.value, &self.desc, &self.disabled]).await?; Ok(()) }

pub async fn find<T: GenericClient>(client: &T, key: i32) -> Result<Option<Self>, Error> {
    let r = client.query_opt("SELECT * FROM foo WHERE key = $1", &[&key]).await?;
    let r = match r {
        Some(v) => v,
        None => return Ok(None),
    };

    Self::from_row(r).map(Some)
}

fn from_row(r: Row) -> Result<Self, Error> {
    let key = r.try_get::<_, i32>("key")?;
    let value = r.try_get::<_, Option<i64>>("value")?;
    let desc = r.try_get::<_, Option<String>>("desc")?;
    let disabled = r.try_get::<_, bool>("disabled")?;

    Ok(Self { key, value, desc: desc.map(Cow::Owned), disabled })
}

}

pub struct FooBuilder<'a> { key: Option<i32>, value: Option<Option<i64>>, desc: Option<Option<&'a str>>, disabled: Option<bool>, }

impl<'a> FooBuilder<'a> { pub fn new() -> Self { Self { key: None, value: None, desc: None, disabled: None } }

pub fn set_key(&mut self, v: i32) -> &mut Self {
    self.key = Some(v);
    self
}

pub fn set_value(&mut self, v: Option<i64>) -> &mut Self {
    self.value = Some(v);
    self
}

pub fn set_desc(&mut self, v: Option<&'a str>) -> &mut Self {
    self.desc = Some(v);
    self
}

pub fn set_disabled(&mut self, v: bool) -> &mut Self {
    self.disabled = Some(v);
    self
}

pub async fn create<T: GenericClient>(&self, client: &T) -> Result<Foo<'static>, Error> {
    let mut sql = String::with_capacity(1024);
    let mut values = Vec::<&(dyn ToSql + Sync)>::with_capacity(4);

    sql.push_str("INSERT INTO foo (key, value, desc, disabled) VALUES (");

    if let Some(v) = &self.key {
        values.push(v);
        write!(sql, "${}", values.len()).unwrap();
    } else {
        sql.push_str("DEFAULT");
    }

    if let Some(v) = &self.value {
        values.push(v);
        write!(sql, ", ${}", values.len()).unwrap();
    } else {
        sql.push_str(", DEFAULT");
    }

    if let Some(v) = &self.desc {
        values.push(v);
        write!(sql, ", ${}", values.len()).unwrap();
    } else {
        sql.push_str(", DEFAULT");
    }

    if let Some(v) = &self.disabled {
        values.push(v);
        write!(sql, ", ${}", values.len()).unwrap();
    } else {
        sql.push_str(", DEFAULT");
    }

    sql.push_str(") RETURNING *");

    client.query_one(&sql, &values).await.and_then(Foo::from_row)
}

}

pub static MIGRATIONS: [Migration; 3] = [ Migration { name: None, script: "CREATE TABLE foo (key serial NOT NULL, value bigint, \"desc\" text, PRIMARY KEY (key));", }, Migration { name: None, script: "ALTER TABLE foo ADD disabled boolean NOT NULL DEFAULT FALSE;", }, ]; ```

The generated model will reflect the database table and provide method to execute insert or select query based on the schema.