Struct sql_abstractor::Postgres

pub struct Postgres { /* private fields */ }

Postgress implementation.

It’s a wrapper around sqlx::postgres

Examples

It implemeents orchestrator memory abstraction, that means that could be used as:

use sql_abstractor::Postgres;
use orchestrator::prelude::*;
 
GenerateState!(ExerciseResult, DummyExercise);
let m = Box::new(
    Postgres::clean_init("postgresql://postgres:test@localhost:5432/thesis")
    .await
    .unwrap(),
);
let mut o: Orchestrator<State> = Orchestrator::new(1, m);
o.run().await;

Implementations

impl Postgres

implement some initialization

pub async fn init(builder: &str) -> Result<Self, Error>

initialize connector It could be used multiple times without loosing any data.

This is the correct way to obtain Self

pub async fn clean_init(builder: &str) -> Result<Self, Error>

WARNING: THIS WILL ERASE ALL THE DATA CONTAINED IN THE DATABASE, AND THEN INIT

Trait Implementations

impl<S: ExecutorGlobalState> StateMemory<S> for Postgres

state memory implementation

fn get_exercise<'life0, 'async_trait>( &'life0 self, name: String, ) -> Pin<Box<dyn Future<Output = Result<(TypeId, String), Box<dyn StdError + Send + Sync + 'static>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

get an exercise from memory type, source

fn enable_executor<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, input: &'life1 S, output: &'life2 S, data: String, ) -> Pin<Box<dyn Future<Output = Result<(), Box<dyn StdError + Send + Sync + 'static>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

used to enable a particular executor

fn get_execution_plan<'life0, 'life1, 'async_trait>( &'life0 self, input: &'life1 S, ) -> Pin<Box<dyn Future<Output = Result<Vec<(TypeId, TypeId, String)>, Box<dyn StdError + Send + Sync + 'static>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

from a particular state, which executor will be triggered? in which order?

fn add_exercise<'life0, 'async_trait>( &'life0 self, name: String, exercise_type: S, source: String, ) -> Pin<Box<dyn Future<Output = Result<(), Box<dyn StdError + Send + Sync + 'static>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

add an exercise to memory

impl StatelessMemory for Postgres

implementation of the StatelessMemory trait

fn login<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, username: &'life1 str, password: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<User<Authenticated>, Box<dyn StdError>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

tries to login the current user, returning an authenticated user instance

fn get_by_username<'life0, 'life1, 'async_trait>( &'life0 self, username: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<User<Unauthenticated>, Box<dyn StdError>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

gets a user by his username

fn get_all_users<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<User<Unauthenticated>>, Box<dyn StdError>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

returns all user present in the DB.

fn get_authenticate<'life0, 'life1, 'async_trait>( &'life0 self, token: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<User<Authenticated>, Box<dyn StdError>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

check if the given token is valid, and if so returns the correct user

fn get_admin<'life0, 'life1, 'async_trait>( &'life0 self, token: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<User<Admin>, Box<dyn StdError>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

if the token is valid, it get’s the user, and if so checks if it is an Admin

fn add_submission<'life0, 'async_trait>( &'life0 self, exercise_name: String, source: String, user: User<Authenticated>, ) -> Pin<Box<dyn Future<Output = Result<i64, Box<dyn StdError + Send + Sync>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

add submission (on success returns submission id)

fn add_exercise_result<'life0, 'async_trait>( &'life0 self, submission_id: i64, user: User<Authenticated>, result: ExerciseResult, ) -> Pin<Box<dyn Future<Output = Result<(), Box<dyn StdError + Send + Sync>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

add exercise result

fn register<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, username: &'life1 str, password: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<User<Unauthenticated>, Box<dyn StdError>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

register User, it should not authenticate it

fn list_exercise_names<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, Box<dyn StdError>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

list exercises names