Crate parsql_tokio_postgres

parsql-tokio-postgres

Asynchronous PostgreSQL integration for parsql using tokio-postgres. This crate provides async/await APIs for working with PostgreSQL databases.

Features

• Asynchronous PostgreSQL operations
• Automatic SQL query generation
• Secure parameter management
• Generic CRUD operations
• Deadpool connection pool support
• SQL Injection protection
• Detailed error reporting

Usage

use tokio_postgres::{NoTls, Error};
use parsql::tokio_postgres::{CrudOps};
use parsql::macros::{Insertable, Queryable, SqlParams, FromRow};
 
#[derive(Insertable, SqlParams)]
#[table("users")]
pub struct InsertUser {
    pub name: String,
    pub email: String,
}
 
#[derive(Queryable, SqlParams, FromRow)]
#[table("users")]
#[where_clause("id = $")]
pub struct GetUser {
    pub id: i32,
    pub name: String,
    pub email: String,
}
 
impl GetUser {
    pub fn new(id: i32) -> Self {
        Self {
            id,
            name: Default::default(),
            email: Default::default(),
        }
    }
}
 
#[tokio::main]
async fn main() -> Result<(), Error> {
    let (client, connection) = tokio_postgres::connect(
        "host=localhost user=postgres dbname=test",
        NoTls,
    ).await?;
     
    tokio::spawn(async move {
        if let Err(e) = connection.await {
            eprintln!("Connection error: {}", e);
        }
    });
     
    // Insert a new user
    let insert_user = InsertUser {
        name: "John".to_string(),
        email: "john@example.com".to_string(),
    };
     
    // Extension method style
    let id = client.insert(insert_user).await?;
     
    // Get the user back
    let get_user = GetUser::new(id as i32);
    let user = client.fetch(get_user).await?;
     
    println!("User: {:?}", user);
    Ok(())
}

The trait-based extension methods can also be used with client objects from deadpool-postgres:

use parsql::tokio_postgres::CrudOps;
use deadpool_postgres::{Config, Pool};
use tokio_postgres::NoTls;

async fn example() -> Result<(), Box<dyn std::error::Error>> {
    let mut cfg = Config::new();
    cfg.host = Some("localhost".to_string());
    cfg.user = Some("postgres".to_string());
     
    let pool = cfg.create_pool(None, NoTls)?;
     
    // Get client from pool
    let client = pool.get().await?;
     
    // Use extension methods
    let users = client.fetch_all(active_users_query).await?;
     
    Ok(())
}

Re-exports

pub use crate::crud_ops::CrudOps;

pub use crate::crud_ops::insert;

pub use crate::crud_ops::update;

pub use crate::crud_ops::delete;

pub use crate::crud_ops::fetch;

pub use crate::crud_ops::fetch_all;

pub use crate::crud_ops::select;

pub use crate::crud_ops::select_all;

pub use crate::crud_ops::get;Deprecated

pub use crate::crud_ops::get_all;Deprecated

pub use transaction_ops as transactional;

pub use parsql_macros as macros;

Modules

crud_ops

transaction_ops

Transaction support module

Structs

Client

An asynchronous PostgreSQL client.

Error

An error communicating with the Postgres server.

Row

A row of data returned from the database by a query.

Traits

FromRow

Trait for converting database rows to Rust structs. This trait is implemented by the derive macro FromRow.

SqlParams

Trait for providing SQL parameters. This trait is implemented by the derive macro SqlParams.

SqlQuery

Trait for generating SQL queries. This trait is implemented by the derive macro Queryable, Insertable, Updateable, and Deletable.

ToSql

A trait for types that can be converted into Postgres values.

UpdateParams

Trait for providing UPDATE parameters. This trait is implemented by the derive macro UpdateParams.