Struct PostgresBackend 

pub struct PostgresBackend { /* private fields */ }

Postgres-backed DatabaseBackend using JSONB document rows.

Examples

use std::sync::Arc;
use valence::{
    valence_schema, Database, DatabaseFromEngine, FieldType, PostgresBackend, Valence,
    POSTGRES_ENGINE_ID,
};

const COUNTER_DB: DatabaseFromEngine =
    Database::from_engine("default", POSTGRES_ENGINE_ID);

valence_schema! {
    Counter {
        table: "counter",
        version: "0.1.0",
        database: COUNTER_DB,
        fields: [
            id: { r#type: FieldType::String, primary_key: true, required: true },
            value: { r#type: FieldType::Integer, required: true },
        ],
    }
}

// Reads DATABASE_URL.
let backend = PostgresBackend::from_env().await?;
let valence = Valence::builder()
    .add_backend("default", Arc::new(backend))
    .build()?;
assert_eq!(
    valence.backend_for_table("counter")?.engine_id(),
    POSTGRES_ENGINE_ID
);

Implementations

impl PostgresBackend

pub fn builder() -> PostgresBackendBuilder

Start a builder for explicit host wiring.

pub async fn from_env() -> Result<PostgresBackend, Error>

Connect using env defaults via builder (shorthand).

pub async fn connect(url: &str) -> Result<PostgresBackend, Error>

Connect using a Postgres connection URL.

pub fn pool(&self) -> &Pool<Postgres>

Borrow the underlying pool.

Trait Implementations

impl Clone for PostgresBackend

fn clone(&self) -> PostgresBackend

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl DatabaseBackend for PostgresBackend

fn engine_id(&self) -> &'static str

Stable open engine slug for router keys (see crate::router_key()).

fn capabilities(&self) -> BackendCapabilities

Adapter capabilities for contract tests and telemetry.

fn execute_compiled_query<'life0, 'life1, 'async_trait>( &'life0 self, compiled: &'life1 CompiledQuery, ) -> Pin<Box<dyn Future<Output = Result<Vec<Value>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, PostgresBackend: 'async_trait,

Execute a compiled admin/query statement and return JSON rows.

fn ensure_schemaless_table<'life0, 'life1, 'async_trait>( &'life0 self, table: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, PostgresBackend: 'async_trait,

Ensure a schemaless table exists before first write.

fn get_record<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, table: &'life1 str, id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Value>, Error>> + Send + 'async_trait>>

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

Fetch one record by primary key.

fn create_record<'life0, 'life1, 'async_trait>( &'life0 self, table: &'life1 str, content: Value, ) -> Pin<Box<dyn Future<Output = Result<Value, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, PostgresBackend: 'async_trait,

Insert a new record; content must include any required fields.

fn update_record<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, table: &'life1 str, id: &'life2 str, content: Value, ) -> Pin<Box<dyn Future<Output = Result<Value, Error>> + Send + 'async_trait>>

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

Replace an existing record by id.

fn merge_record<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, table: &'life1 str, id: &'life2 str, patch: Value, ) -> Pin<Box<dyn Future<Output = Result<Value, Error>> + Send + 'async_trait>>

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

Patch an existing record with a partial JSON object.

fn upsert_record<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, table: &'life1 str, id: &'life2 str, content: Value, ) -> Pin<Box<dyn Future<Output = Result<Value, Error>> + Send + 'async_trait>>

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

Create or replace a record by explicit id.

fn delete_record<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, table: &'life1 str, id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Delete one record by primary key.

fn relate_edge<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, from: &'life1 RecordId, edge_table: &'life2 str, to: &'life3 RecordId, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, PostgresBackend: 'async_trait,

Create a directed graph edge from from to to through edge_table.

fn unrelate_edge<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, from: &'life1 RecordId, edge_table: &'life2 str, to: &'life3 RecordId, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, PostgresBackend: 'async_trait,

Remove a directed graph edge.

fn get_edge_targets<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, from: &'life1 RecordId, edge_table: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<RecordId>, Error>> + Send + 'async_trait>>

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

List target record ids reachable via outgoing edges in edge_table.

fn define_unique_index<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, table: &'life1 str, field: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Define a unique index on table.field when the engine supports DDL.

fn ttl_capability(&self) -> BackendTtlCapability

Whether this adapter can apply schema TTL policies natively.

fn apply_ttl_policy<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _table: &'life1 str, _policy: &'life2 SchemaTtlPolicy, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Apply a schema TTL policy to table when supported.

fn use_namespace<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ns: &'life1 str, db_name: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

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

Select namespace/database on engines that support multi-tenant routing.

impl Debug for PostgresBackend

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

Formats the value using the given formatter.