pgde

A simple library for consuming tokio_postgres::row::Row data into structs that derive the RowConsumer trait.

This crate provides a variety of derivable implementations that can be used to consume PostgreSQL data depending on preference.

• from_row
• from_rows
• consume
• consume_json if feature consume_json is enabled

The latter implementations are built from from_row.

Features

A variety of features provide support for additional implementation and types.

Examples

You may use consume to consume PostgreSQL row data into a struct like so.

# tokio_test::block_on(async {
use pgde::ConsumeError;
use pgde::RowConsumer;
use pgde_derive::RowConsumer;
use tokio_postgres::{NoTls, Row};

#[derive(RowConsumer)]
struct Foo {
    Id: i32,
    Data: String,
}

match tokio_postgres::connect("host=localhost user=postgres password=password dbname=postgres", NoTls).await {
    Ok(v) => {
        let client = v.0;
        let conn = v.1;

        tokio::spawn(async move {
            if let Err(e) = conn.await {
                eprintln!("connection error: {}", e);
            }
        });

        let query = "select * from public.\"Foo\";";

        match Foo::consume(&client, query, &[]).await {
            Ok(v) => { // v is of type Vec<Foo>
                match v.first() {
                    Some(v) => println!("Id {} has Data {}", v.Id, v.Data),
                    None => eprintln!("No data in table"),
                }
            },
            Err(v) => match v {
                ConsumeError::ConversionError => eprintln!("Could not convert data"),
                ConsumeError::DatabaseConnectionError => eprintln!("Database errored on processing the query"),
            },
        };
    },
    Err(_) => eprintln!("Could not connect to database"),
};
# })

Types of Vec<T> and Option<T>, where T implements FromSql, are also supported on structs, or as standalone consuming types, that derive RowConsumer. When querying nullable fields, it is best to wrap field types in an Option<>. See the RowConsumer trait for use examples of from_row and from_rows.

This crate also provides implementations on a variety of data types, some provided by enabling features.

Testing

Testing requires access to a PostgreSQL database with no tables. Setting the following environment variables will allow you to test.