co-orm

A high-performance, async CRUD library for sqlx that provides elegant database operations with compile-time safety.

Features

• Zero-cost abstractions - Minimal runtime overhead
• Type-safe queries - Compile-time SQL generation
• Async-first - Built on tokio and sqlx
• Flexible filtering - Powerful WHERE clause builder
• Multiple databases - MySQL, PostgreSQL, SQLite support
• Macro-driven - Simple derive macros for common operations

Installation

Add to your Cargo.toml:

[dependencies]
co-orm = { version = "0.3", features = ["mysql"] }
sqlx = { version = "0.8", features = ["mysql", "runtime-tokio-native-tls"] }

Available features: mysql, postgres, sqlite

Quick Start

Basic Model Definition

use co_orm::{Crud, sqlx::FromRow};
use chrono::NaiveDateTime;

#[derive(Debug, Crud, FromRow)]
#[co_orm(rename = "users")]
struct User {
    #[co_orm(skip_insert)]
    pub id: i64,
    #[co_orm(rename = "name")]
    pub name: String,
    #[co_orm(update)]
    pub password: String,
    #[co_orm(skip)]
    #[sqlx(skip)]
    pub addr: Option<String>,
    pub age: Option<u32>,
    #[co_orm(skip_insert)]
    pub update_at: Option<NaiveDateTime>,
}

Basic CRUD Operations

use co_orm::{Crud, Where};

// Get by primary key
let user = User::get(&pool, 1).await?;

// Query all
let users = User::query(&pool).await?;

// Insert
let new_user = User { /* ... */ };
new_user.insert(&pool).await?;

// Update
user.update(&pool).await?;

// Delete
user.delete(&pool).await?;

Advanced Querying

// Simple conditions
let users = User::query_where(&pool, Where::new()
    .eq("status", "active")
    .and()
    .ge("age", 18)
).await?;

// Complex grouped conditions
let users = User::query_where(&pool, Where::new()
    .eq("status", "active")
    .and_group(|w| {
        w.gt("age", 18)
         .and()
         .lt("age", 65)
    })
    .or_group(|w| {
        w.eq("name", "admin")
         .and()
         .ge("age", 21)
    })
).await?;

// Pagination
let (count, users) = User::query_page_where(
    &pool,
    Where::new().eq("status", "active"),
    1,  // page
    10  // page_size
).await?;

Available Methods

The #[derive(Crud)] macro generates these methods:

• Read: get(), get_by(), get_where(), query(), query_by(), query_where()
• Write: insert(), insert_all(), update(), update_by(), update_where()
• Delete: delete(), delete_by(), delete_where()
• Pagination: query_page_by(), query_page_where()

Field Attributes

Query Operators

Logical Operators

Utility Macros

// Query arguments
let args = args!(&name, age);

// Pagination arguments  
let args = page_args!(&name, age);

// Raw queries
query!("INSERT INTO users (name, password) VALUES (?, ?)", name, password)
    .execute(&pool).await?;

// Typed queries
query_as!(User, "SELECT * FROM users WHERE name = ?", name)
    .fetch_one(&pool).await?;

Examples

See the examples/ directory for complete working examples:

• crud.rs - Basic CRUD operations
• where_examples.rs - Advanced querying patterns
• pool.rs - Connection pool management

License

Licensed under the MIT License.