rizzle [wip]

rizzle is an automatic migration generator and query builder for sqlite (*postgres coming at some point) for rust!

May or may not be inspired by drizzle

Install

sh cargo add rizzle

Declare your schema and connect to database

```rust use rizzle::prelude::*;

[derive(Table, Clone, Copy)]

[rizzle(table = "posts")]

struct Posts { #[rizzle(primary_key)] id: Integer,

#[rizzle(not_null)] body: Text }

[derive(Table, Clone, Copy)]

[rizzle(table = "comments")]

struct Comments { #[rizzle(primary_key)] id: Integer,

#[rizzle(not_null)]
body: Text,

#[rizzle(references = "posts(id)")]
post_id: Integer,

}

[derive(RizzleSchema, Clone, Copy)]

struct Schema { posts: Posts, comments: Comments }

[tokio::main]

async fn main() -> Result<(), RizzleError> { let options = DatabaseOptions::new("sqlite://:memory:"); let schema = Schema::new(); let db = rizzle(options, schema).await?; Ok(()) } ```

Inserting, updating, and deleting rows

```rust use rizzle::prelude::*;

[derive(Row)]

struct Post { id: i64, body: String }

[tokio::main]

async fn main() -> Result<(), RizzleError> { let options = DatabaseOptions::new("sqlite://:memory:"); let schema = Schema::new(); let db = rizzle(options, schema).await?; let Schema { posts, .. } = schema;

// insert into posts (id, body) values (?, ?) returning *
let inserted_post: Post = db
    .insert(posts)
    .values(Post {
        id: 1,
        body: "".to_owned(),
    })
    .returning()
    .await?;

// update posts set body = ?, id = ? where id = ?
let rows_affected = db
    .update(posts)
    .set(Post {
        body: "post".to_owned(),
        ..inserted_post
    })
    .where(eq(posts.id, 1))
    .rows_affected()
    .await?;

// delete from posts where id = ? returning *
let deleted_post = db.delete(posts).where(eq(posts.id, 1)).returning().await?;

Ok(())

} ```

Selecting rows with *

```rust use rizzle::prelude::*;

[derive(Row)]

struct Comment { id: i64, body: String, post_id: i64 }

[tokio::main]

async fn main() -> Result<(), RizzleError> { let options = DatabaseOptions::new("sqlite://:memory:"); let schema = Schema::new(); let db = rizzle(options, schema).await?; let Schema { comments, .. } = schema;

// select * from comments
let rows: Vec<Comment> = db.select().from(comments).all().await;

Ok(())

} ```

Selecting specific columns

```rust use rizzle::prelude::*;

[derive(Select, Default)]

struct PartialComment { body: String }

[tokio::main]

async fn main() -> Result<(), RizzleError> { let options = DatabaseOptions::new("sqlite://:memory:"); let schema = Schema::new(); let db = rizzle(options, schema).await?; let Schema { comments, .. } = schema; let partial_comment = PartialComment::default();

// select body from comments
let partial_rows: Vec<PartialComment> = db.select_with(partial_comment).from(comments).all().await;

Ok(())

} ```

Joins

```rust use rizzle::prelude::*;

[tokio::main]

async fn main() -> Result<(), RizzleError> { let options = DatabaseOptions::new("sqlite://:memory:"); let schema = Schema::new(); let db = rizzle(options, schema).await?; let Schema { comments, posts } = schema;

// select * from comments inner join posts on posts.id = comments.post_id
let rows: Vec<Comment> = db
    .select()
    .from(comments)
    .inner_join(posts, on(posts.id, comments.post_id))
    .all()
    .await;

Ok(())

} ```

Prepared statements

```rust use rizzle::prelude::*;

[tokio::main]

async fn main() -> Result<(), RizzleError> { let options = DatabaseOptions::new("sqlite://:memory:"); let schema = Schema::new(); let db = rizzle(options, schema).await?; let Schema { comments, .. } = schema;

// select * from comments
let query = db.select().from(comments);

// prepare the query store it in a once lock or something
let prepared = query.prepare_as::<Comment>();

// execute the prepared query later
let rows = prepared.all().await?;

Ok(())

} ```