Struct Defective 

pub struct Defective<'a, R> { /* private fields */ }

A backend with one Defect injected. The wrapped backend does the work.

Implementations

impl<'a, R: RelationalBackend> Defective<'a, R>

pub fn new(inner: &'a R, defect: Defect) -> Self

Wrap inner so it is wrong in exactly the way defect says.

Trait Implementations

impl<'a, R: Debug> Debug for Defective<'a, R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R: RelationalBackend> Migrates for Defective<'_, R>

The known-bad migrator: no ledger, no checksum, no transaction. It runs each migration’s statements (split on ;) straight on the wrapped backend every time it is asked.

async fn migrate( &self, migrations: &[Migration], ) -> Result<MigrateReport, MigrateError>

Apply migrations in version order, skipping those already applied. Each migration runs in its own transaction where the database can; refuses (applying nothing further) if an applied migration’s text has changed, if the database has applied a version the program does not know, or if a migration is recorded as dirty.

async fn applied_versions(&self) -> Result<Vec<i64>, MigrateError>

The versions the ledger says succeeded, ascending; empty if there is no ledger yet.

impl<R: RelationalBackend> RelationalBackend for Defective<'_, R>

type Tx<'a> = DefectiveTx<'a, R> where Self: 'a

A transaction on this backend. Dropping it without commit rolls it back.

fn backend(&self) -> &str

The backend’s name as it appears in matrix rows (postgres).

fn version(&self) -> &str

The server version string as it appears in matrix rows (16.15).

fn dialect(&self) -> Dialect

The dialect statements must be written in.

async fn execute(&self, sql: &str, params: &[Value]) -> Result<u64, RelError>

Run a statement that returns no rows; the result is the number of rows affected.

async fn query(&self, sql: &str, params: &[Value]) -> Result<Vec<Row>, RelError>

Run a statement and return its rows.

async fn begin( &self, isolation: Isolation, ) -> Result<DefectiveTx<'_, R>, RelError>

Begin a transaction at (at least) isolation.

fn call_bound(&self) -> Option<Duration>

The per-call timeout this backend enforces, if one is configured; None (the default) means a call waits as long as the server does. Every call that takes longer returns RelError::Timeout.

fn with_lock_held<'a>( &'a self, lock_sql: &'a str, at_most: Duration, during: Pin<Box<dyn Future<Output = ()> + Send + 'a>>, ) -> impl Future<Output = Result<(), RelError>> + Send

Test support for kv.bounded_call: take lock_sql (a statement that locks a row) in a transaction of its own, drive during while that lock is held, then roll back. during is dropped, unfinished, after at_most, so a broken bound cannot hang the test. A backend that enforces no bound returns RelError::Unsupported.