Rustorm

An ORM for rust

Features

• Fluent high-level and low-level API
• Composable queries
• Extensible to multiple database platform
• Easy to reason out generated SQL
• Optional model code generator

Documentation

Example

• Get all contents of product table

```rust

extern crate rustorm; extern crate uuid; extern crate chrono; extern crate rustc_serialize;

use uuid::Uuid; use chrono::datetime::DateTime; use chrono::offset::utc::UTC; use rustc_serialize::json;

use rustorm::query::Query; use rustorm::query::{Filter,Equality}; use rustorm::dao::{Dao,IsDao}; use rustorm::pool::ManagedPool; use rustorm::table::{IsTable,Table};

[derive(Debug, Clone)]

pub struct Product { pub product_id:Uuid, pub name:Option, pub description:Option, }

impl IsDao for Product{ fn fromdao(dao:&Dao)->Self{ Product{ productid: dao.get("productid"), name: dao.getopt("name"), description: dao.getopt("description"), } } fn todao(&self)->Dao{ let mut dao = Dao::new(); dao.set("productid", &self.productid); match self.name{ Some(ref value) => dao.set("name", _value), None => dao.setnull("name"), }; match self.description{ Some(ref value) => dao.set("description", _value), None => dao.setnull("description"), }; dao } }

impl IsTable for Product{

fn table()->Table{
    Table{
        schema:"bazaar".to_string(),
        name:"product".to_string(),
        parent_table:None,
        sub_table:vec![],
        comment:None,
        columns:vec![]
    }
}

}

fn main(){ let url = "postgres://postgres:p0stgr3s@localhost/bazaar_v6"; let mut pool = ManagedPool::init(&url, 1); let db = pool.connect().unwrap();

let products: Vec<Product> = Query::select_all()
        .from_table("bazaar.product")
        .collect(db.as_mut());

for prod in products{
    let name = prod.name.unwrap();
    let desc = match prod.description{
                    Some(desc) => desc,
                    None => "".to_string()
                };
    println!("{}  {}  {:?}", prod.product_id, name, desc);
}

} ```

• Get one photo of a product

```rust

[derive(Debug, Clone)]

pub struct Photo { pub photo_id:Uuid, pub url:Option, }

impl IsDao for Photo{ fn fromdao(dao:&Dao)->Self{ Photo{ photoid: dao.get("photoid"), url: dao.getopt("url"), } } fn todao(&self)->Dao{ let mut dao = Dao::new(); dao.set("photoid", &self.photoid); match self.url{ Some(ref _value) => dao.set("url", _value), None => dao.setnull("url"), }; dao } }

impl IsTable for Photo{

fn table()->Table{
    Table{
        schema:"bazaar".to_string(),
        name:"photo".to_string(),
        parent_table:None,
        sub_table:vec![],
        comment:None,
        columns:vec![]
    }
}

}

fn main(){ let url = "postgres://postgres:p0stgr3s@localhost/bazaar_v6"; let mut pool = ManagedPool::init(url, 1); let db = pool.connect().unwrap();

let photo: Photo = Query::select_all()
                    .column("photo.url")
                    .from_table("bazaar.product")
                    .left_join_table("bazaar.product_photo",
                        "product.product_id", "product_photo.product_id")
                    .left_join_table("bazaar.photo",
                        "product_photo.photo_id", "photo.photo_id")
                    .filter("product.name", Equality::EQ, &"GTX660 Ti videocard")
                    .collect_one(db.as_ref()).unwrap();

println!("photo: {} {}",photo.photo_id, photo.url.unwrap());

}

```

• One complex query

```rust

[derive(Debug, Clone)]

pub struct Photo { pub photo_id:Uuid, pub url:Option, }

impl IsDao for Photo{ fn fromdao(dao:&Dao)->Self{ Photo{ photoid: dao.get("photoid"), url: dao.getopt("url"), } } fn todao(&self)->Dao{ let mut dao = Dao::new(); dao.set("photoid", &self.photoid); match self.url{ Some(ref _value) => dao.set("url", _value), None => dao.setnull("url"), }; dao } }

fn main(){ let url = "postgres://postgres:p0stgr3s@localhost/bazaar_v6"; let mut pool = ManagedPool::init(&url, 1); let db = pool.connect().unwrap();

let mut query = Query::select_all();

query.from_table("bazaar.product")
    .left_join_table("bazaar.product_category",
        "product_category.product_id", "product.product_id")
     .left_join_table("bazaar.category",
        "category.category_id", "product_category.category_id")
    .left_join_table("product_photo",
        "product.product_id", "product_photo.product_id")
    .left_join_table("bazaar.photo", 
        "product_photo.photo_id", "photo.photo_id")
    .filter("product.name", Equality::EQ, &"GTX660 Ti videocard")
    .filter("category.name", Equality::EQ, &"Electronic")
    .group_by(vec!["category.name"])
    .having("count(*)", Equality::GT, &1)
    .asc("product.name")
    .desc("product.created")
    ;
let frag = query.build(db.as_ref());

let expected = "

SELECT * FROM bazaar.product LEFT OUTER JOIN bazaar.productcategory ON productcategory.productid = product.productid LEFT OUTER JOIN bazaar.category ON category.categoryid = productcategory.categoryid LEFT OUTER JOIN productphoto ON product.productid = productphoto.productid LEFT OUTER JOIN bazaar.photo ON productphoto.photoid = photo.photoid WHERE product.name = $1 AND category.name = $2 GROUP BY category.name HAVING count(*) > $3 ORDER BY product.name ASC, product.created DESC".to_string(); println!("actual: {{{}}} [{}]", frag.sql, frag.sql.len()); println!("expected: {{{}}} [{}]", expected, expected.len()); assert!(frag.sql.trim() == expected.trim());

}

```

Supported Database

• [x] PostgreSQL
• [x] Sqlite
• [x] MySQL/MariaDB
• [ ] Oracle

Roadmap

• Support for Oracle
• Support for MySql

For Updates

Follow me on twitter: @ivanceras

Support this project

• This is a 1 man show, so if you feel generous, please support this project at bountysource bountysource

• Suggestions are much welcome!