Struct PostgresDb 

pub struct PostgresDb<Config>
where
    Config: Config,
{ /* private fields */ }

Implementations

impl<Config> PostgresDb<Config>

where Config: Config,

pub async fn connect( db: Pool<Postgres>, cache_watermark: usize, ) -> Result<Arc<CacheDb<PostgresDb<Config>>>, Error>

pub async fn update_users_who_can_read<C>( &self, requested_by: ObjectId, object_id: ObjectId, cb: &C, ) -> Result<ReadPermsChanges, Error>

where C: CanDoCallbacks,

Update the list of users who can read object

_lock is a lock that makes sure object is not being modified while this executes.

Trait Implementations

impl<Config> Db for PostgresDb<Config>

where Config: Config,

async fn reencode_old_versions<T>(&self) -> usize

where T: Object,

Returns the number of errors that happened while re-encoding

async fn create<T>( &self, object_id: ObjectId, created_at: EventId, object: Arc<T>, updatedness: Option<Updatedness>, _importance: Importance, ) -> Result<Option<Arc<T>>, Error>

where T: Object,

Returns the new latest snapshot if it actually changed

async fn submit<T>( &self, object_id: ObjectId, event_id: EventId, event: Arc<<T as Object>::Event>, updatedness: Option<Updatedness>, _additional_importance: Importance, ) -> Result<Option<Arc<T>>, Error>

where T: Object,

Returns the new latest snapshot if it actually changed

async fn get_latest<T>( &self, object_id: ObjectId, _importance: Importance, ) -> Result<Arc<T>, Error>

where T: Object,

async fn create_binary( &self, binary_id: BinPtr, data: Arc<[u8]>, ) -> Result<(), Error>

async fn get_binary( &self, binary_id: BinPtr, ) -> Result<Option<Arc<[u8]>>, Error>

async fn assert_invariants_generic(&self)

async fn assert_invariants_for<T>(&self)

where T: Object,

impl<Config> ServerSideDb for PostgresDb<Config>

where Config: Config,

fn get_users_who_can_read<'a, 'ret, T, C>( &'ret self, object_id: ObjectId, object: &'a T, cb: &'a C, ) -> Pin<Box<dyn Future<Output = Result<UsersWhoCanRead<<PostgresDb<Config> as ServerSideDb>::Lock<'ret>>, Error>> + 'a>>

where 'ret: 'a, T: Object, C: CanDoCallbacks,

This function assumes that the lock on object_id is already taken.

async fn server_vacuum( &self, no_new_changes_before: Option<EventId>, updatedness: Updatedness, kill_sessions_older_than: Option<SystemTime>, notify_recreation: impl FnMut(Update, HashSet<User>), ) -> Result<(), Error>

Cleans up and optimizes up the database

After running this, the database will reject any new change that would happen before no_new_changes_before if it is set.

type Connection = PgConnection

type Transaction<'a> = Transaction<'a, Postgres>

type Lock<'a> = (Lock, <LockPool<ObjectId> as Lockable<ObjectId, ()>>::Guard<'a>)

async fn get_transaction(&self) -> Result<Transaction<'_, Postgres>, Error>

async fn get_latest_snapshot( &self, transaction: &mut PgConnection, user: User, object_id: ObjectId, ) -> Result<Arc<Value>, Error>

async fn get_all( &self, transaction: &mut PgConnection, user: User, object_id: ObjectId, only_updated_since: Option<Updatedness>, ) -> Result<ObjectData, Error>

async fn server_query( &self, user: User, type_id: TypeId, only_updated_since: Option<Updatedness>, query: Arc<Query>, ) -> Result<Vec<ObjectId>, Error>

async fn recreate_at<'a, T, C>( &'a self, object_id: ObjectId, event_id: EventId, updatedness: Updatedness, cb: &'a C, ) -> Result<Option<(EventId, Arc<T>)>, Error>

where T: Object, C: CanDoCallbacks,

This function assumes that the lock on object_id is already taken

async fn create_and_return_rdep_changes<T>( &self, object_id: ObjectId, created_at: EventId, object: Arc<T>, updatedness: Updatedness, ) -> Result<Option<(Arc<T>, Vec<ReadPermsChanges>)>, Error>

where T: Object,

async fn submit_and_return_rdep_changes<T>( &self, object_id: ObjectId, event_id: EventId, event: Arc<<T as Object>::Event>, updatedness: Updatedness, ) -> Result<Option<(Arc<T>, Vec<ReadPermsChanges>)>, Error>

where T: Object,

async fn update_pending_rdeps(&self) -> Result<(), Error>

async fn login_session( &self, session: Session, ) -> Result<(SessionToken, SessionRef), Error>

async fn resume_session(&self, token: SessionToken) -> Result<Session, Error>

async fn mark_session_active( &self, token: SessionToken, at: SystemTime, ) -> Result<(), Error>

async fn rename_session<'a>( &'a self, token: SessionToken, new_name: &'a str, ) -> Result<(), Error>

async fn list_sessions(&self, user: User) -> Result<Vec<Session>, Error>

async fn disconnect_session( &self, user: User, session: SessionRef, ) -> Result<(), Error>