cdbc

Coroutine Database driver Connectivity.based on cogo

• High concurrency，based on coroutine
• No Future<'q,Output=*>，No async fn, No .await, no Poll* func，No Pin
• Optimize the trait system so that it has intelligent hints of the base method
• NativeTls and TCP connections are supported
• Low coupling，The database driver and the abstraction layer are designed separately
• Lightweight, no over-design, only have macro with intelligent tips
• Inspired by golang, cogo, sqlx

Why cdbc ？

| crates | Concurrency | feature level | All Smart tips | Libc | have proc macro | separation driver | support env/crates | |--------|---------------|---------------|----------------|------------|----------------------|----------------------|----------------------------------------------------------------------------------| | cdbc | CSP（cogo） | lower | √ | only sqlite | Don't need | √ | cogo, cogo/std/http, native-thread,tokio-spawn_blocking | | rbatis | Future（tokio） | heavy-weight | √ | only sqlite | only pysql,htmlsql | x | tokio, asyncstd, smol | | sqlx | Future（tokio） | lower | x | only sqlite | only derive(StructOpt) | x | tokio, asyncstd, smol | | diesel | Native Thread | lower | x | all-libc | derive(Queryable) | x | native thread |

concurrency benchmark performance(Compare the SQLX/Tokio/Async-std)

| crates | Requests/sec | Mem | CpuLoad | |------------------|--------------|------|--------| | cdbc-cogo-http | 4606 | 30MB | 6% | | sqlx-axum-tokio | 4560 | 17MB | 8% |
| sqlx-actix-async-std | 559.00 | 22MB | 2% |
| diesel | * | * | * |

• benchmark with wrk(docker run -it --net=host --rm williamyeh/wrk -t12 -c400 -d30s http://192.168.28.235:8000)
• see detail benchmark

Database Support:

• cdbc The driver abstraction lib.
• cdbc-mysql CDBC mysql driver library
• cdbc-pg CDBC postgres driver library
• cdbc-sqlite CDBC sqlite driver library

Supported functions

• execute： Execute the query and return the total number of rows affected.
• execute_many： Execute multiple queries and return the rows affected from each query, in a stream.
• fetch： Execute the query and return the generated results as a stream.
• fetch_many： Execute multiple queries and return the generated results as a stream，from each query, in a stream.
• fetch_all： Execute the query and return all the generated results, collected into a [Vec].
• fetch_one： Execute the query and returns exactly one row.
• fetch_optional： Execute the query and returns at most one row.
• prepare： Prepare the SQL query to inspect the type information of its parameters and results
• prepare_with: Prepare the SQL query, with parameter type information, to inspect the type information about its parameters and results.

Supported transaction

• Pool: begin(),commit(),rollback()
• Connection: begin(),commit(),rollback()

use example:

cargo.toml ```toml

must dep

cdbc = {version = "0.1"}

optional dep

cdbc-mysql = {version = "0.1"} cdbc-pg = {version = "0.1"} cdbc-sqlite = {version = "0.1"} * row_scan macro rust use std::fs::File; use cdbc::Executor; use cdbc_sqlite::SqlitePool;

fn main() -> cdbc::Result<()> { let pool = makesqlite()?; #[derive(Debug)] pub struct BizActivity { pub id: Option, pub name: Option, pub deleteflag: Option, }

//execute
let data = pool.acquire()?.execute("update biz_activity set delete_flag where id = \"1\"")?;
println!("{:?}", data.rows_affected());

//fetch_all
let query = cdbc::query("select * from biz_activity where id = ?")
    .bind("1");
let row = pool.acquire()?.fetch_all(query)?;
let data = cdbc::row_scans!(row,BizActivity{id:None,name:None,delete_flag:None})?;
println!("{:?}", data);

//fetch_one
let data = cdbc::row_scan!(
    cdbc::query("select * from biz_activity where id = ?")
    .bind("1")
    .fetch_one(pool)?,
    BizActivity{id:None,name:None,delete_flag:None})?;
println!("{:?}", data);

//transaction
let mut tx = pool.acquire()?.begin()?;
let data=tx.execute("update biz_activity set delete_flag where id = \"1\"")?;
println!("{:?}", data.rows_affected());
tx.commit()?;
Ok(())

}

fn makesqlite() -> cdbc::Result { //first. create sqlite dir/file std::fs::createdirall("target/db/"); File::create("target/db/sqlite.db"); //next create table and query result let pool = SqlitePool::connect("sqlite://target/db/sqlite.db")?; let mut conn = pool.acquire()?; conn.execute("CREATE TABLE bizactivity( id string, name string,age int, deleteflag int) "); conn.execute("INSERT INTO bizactivity (id,name,age,delete_flag) values (\"1\",\"1\",1,0)"); Ok(pool) } ```

• Processing read streams > main.rs ```rust use std::collections::BTreeMap; use cdbc::{Column, Decode, Executor, Row}; use cdbc::io::chanstream::{ChanStream, TryStream}; use cdbcsqlite::{Sqlite, SqliteRow}; use crate::make_sqlite;

  [test]

fn teststreamsqlite() -> cdbc::Result<()> { //first. create sqlite dir/file let pool = makesqlite().unwrap(); //next create table and query result let mut conn = pool.acquire()?; let mut data: ChanStream = conn.fetch("select * from bizactivity;"); data.tryforeach(|item| { let mut m = BTreeMap::new(); for column in item.columns() { let v = item.trygetraw(column.name())?; let r: Option = Decode::<', Sqlite>::decode(v)?; m.insert(column.name().tostring(), r); } println!("{:?}", m); drop(m); Ok(()) })?; Ok(()) } ```