Crate parvati

Parvati SDK

Indeed, an ORM library, not a framework, written in Rust

Features

The main idea that I put into my ORM library is a minimum of stupid code and easy use of the library. I wanted users not to have to write long chains of function calls to construct a simple SQL query.

• SQLite support
• MySQL support

Usage

Cargo.toml

[dependencies]
parvati = {version = "1.0.0", features = ["sqlite"]} # or "mysql"
parvati_derive = "1.0.0"

#[tokio::test]
async fn test() -> Result<(), ORMError> {

    let file = std::path::Path::new("file1.db");
    if file.exists() {
        std::fs::remove_file(file)?;
    }

    let _ = env_logger::Builder::from_env(env_logger::Env::new().default_filter_or("debug")).try_init();

    let conn = ORM::connect("file1.db".to_string())?;
    let init_script = "create_table_sqlite.sql";
    conn.init(init_script).await?;

    #[derive(TableDeserialize, TableSerialize, Serialize, Deserialize, Debug, Clone)]
    #[table(name = "user")]
    pub struct User {
        pub id: i32,
        pub name: Option<String>,
        pub age: i32,
    }

    let mut user = User {
        id: 0,
        name: Some("John".to_string()),
        age: 30,
    };

    let mut user_from_db: User = conn.add(user.clone()).apply().await?;

    user.name = Some("Mary".to_string());
    let  _: User = conn.add(user.clone()).apply().await?;

    let user_opt: Option<User> = conn.find_one(user_from_db.id as u64).run().await?;
    log::debug!("User = {:?}", user_opt);

    let user_all: Vec<User> = conn.find_all().run().await?;
    log::debug!("Users = {:?}", user_all);

    user_from_db.name = Some("Mike".to_string());
    let _updated_rows: usize = conn.modify(user_from_db.clone()).run().await?;


    let user_many: Vec<User> = conn.find_many("id > 0").limit(2).run().await?;
    log::debug!("Users = {:?}", user_many);

    let query = format!("select * from user where name like {}", conn.protect("M%"));
    let result_set: Vec<Row> = conn.query(query.as_str()).exec().await?;
    for row in result_set {
        let id: i32 = row.get(0).unwrap();
        let name: Option<String> = row.get(1);
        log::debug!("User = id: {}, name: {:?}", id, name);
    }

    let updated_rows = conn.query_update("update user set age = 100").exec().await?;
    log::debug!("updated_rows: {}", updated_rows);
    let updated_rows: usize = conn.remove(user_from_db.clone()).run().await?;
    log::debug!("updated_rows: {}", updated_rows);
    conn.close().await?;

    Ok(())
}

Modules

• mysql
  mysql is a module that contains the ORM struct that represents an Object-Relational Mapping (ORM) for a MySQL database.
• sqlite
  sqlite is a module that contains the ORM struct that represents an Object-Relational Mapping (ORM) for a SQLite database.

Structs

• QueryBuilder
  QueryBuilder is a struct that represents a SQL query builder. It is used to construct SQL queries in a safe and convenient manner. The QueryBuilder struct is generic over the lifetime 'a, the result type R, the entity type E, and the ORM type O. The ORM type O must implement the ORMTrait.
• Row
  Row is a struct that represents a row in a database table. It contains a HashMap where the keys are column indices and the values are the column values.

Enums

• ORMError
  ORMError is an enumeration of possible errors that can occur in the ORM library. Each variant represents a different kind of error.

Traits

• ORMTrait
  ORMTrait is a trait that provides methods for interacting with a database. This trait is used to perform operations such as adding data, finding data, modifying data, and removing data. It also provides methods for executing arbitrary queries and escaping strings.
• TableDeserialize
  TableDeserialize is a trait that provides methods for deserializing table data. This trait is used to convert data from a stored or transmitted format into table data.
• TableSerialize
  TableSerialize is a trait that provides methods for serializing table data. This trait is used to convert table data into a format that can be stored or transmitted.