Struct PgStore 

pub struct PgStore { /* private fields */ }

The store on PostgreSQL, with a connection pool. Send + Sync: share one per process (behind an Arc); each call checks a connection out for its duration.

Every put_* is one transaction. Store methods return errors: a malformed argument is Error::Invalid (no query is made), a database failure Error::Database. The Resolver methods answer both with None; a database failure is logged with tracing (target datumesh_store, level error).

Implementations

impl PgStore

pub fn connect(url: &str) -> Result<PgStore>

Connects to a postgres:// URL or key=value connection string with the default PoolOptions: connect_with(url, PoolOptions::new()).

pub fn connect_with(url: &str, options: PoolOptions) -> Result<PgStore>

Connects to a postgres:// URL or key=value connection string, with a pool and TLS roots as options say. One connection is opened at once, so a wrong URL, an unreachable server or a refused certificate fails here; nothing else is done on it (no statement is prepared, the schema is not looked at), so an empty database is fine (create the schema with migrate::apply).

TLS (rustls) is used as the URL’s sslmode says: disable never, prefer (the default) when the server offers it, require always. Whenever it is used, the server’s certificate and host name are verified, against the Mozilla roots plus the roots added with PoolOptions::tls_root_certificates_pem; there is no way to accept any certificate. So a server with ssl=on and a self-signed certificate (or one from a private CA) fails even under the default prefer: add its CA, or connect with sslmode=disable.

pub fn check_statements(&self) -> Result<usize>

Prepares every SQL statement the store uses against the live schema, on a fresh connection’s behalf (no cached statement is reused), and returns how many there are. Fails with the first statement the schema cannot serve.

Trait Implementations

impl Debug for PgStore

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

Formats the value using the given formatter.

impl Resolver for PgStore

fn evaluate(&self, cell: &Cell, asof: &str) -> Option<Scalar>

Some only for a stored function (descriptor code.lang is stored, and the store has the descriptor): the value of the receipt of the cell’s latest version with tx <= asof. None for every other function, and when no version is that old.

fn descriptor(&self, fn_hash: &str) -> Option<Cow<'_, [u8]>>

The descriptor JSON text offered for fn_hash, or None if unavailable (E_FN_UNAVAILABLE). Only None is unavailability: the text is parsed strictly (unparseable text reports its parse code), and any other JSON value, null included, is a descriptor offered that fails the hash check (E_FN_HASH_MISMATCH, SPEC 10.1 step 7.1).

fn receipt(&self, hash: &str) -> Option<Cow<'_, [u8]>>

The receipt JSON text offered for receipt hash hash, or None if unavailable (E_INPUT_UNAVAILABLE).

impl Store for PgStore

fn computed_asof_with_receipt( &self, cell_id: &str, asof: &str, ) -> Result<Option<(Version, Cow<'_, [u8]>)>>

One query: the version and its receipt’s bytes.

fn stored_asof_with_receipt( &self, cell_id: &str, asof: &str, ) -> Result<Option<(Version, Cow<'_, [u8]>)>>

One query: the version and its receipt’s bytes.

fn put_descriptor(&self, bytes: &[u8]) -> Result<String>

Stores a descriptor (checked and canonicalised by the core); returns its function hash. Idempotent.

fn put_receipt(&self, bytes: &[u8]) -> Result<String>

Stores a receipt that verifies (SPEC 10.1 steps 1-6) against the key document stored for its signer host with put_namespace, in canonical form, with an edge to each of its inputs; returns its hash. A receipt that does not verify is refused with verify’s code (no key document for the host: E_KEY_UNAVAILABLE). Idempotent: bytes whose canonical form is the stored copy return its hash without checking the signature again (it verified when stored), even if the key has since been revoked. Other bytes with a stored hash are verified first, then refused as Error::Conflict.

fn put_blob(&self, bytes: &[u8]) -> Result<String>

Stores blob content; returns its SHA-256 (lowercase hex). Idempotent.

fn blob(&self, sha256: &str) -> Result<Option<Cow<'_, [u8]>>>

Blob content by SHA-256.

fn put_version(&self, cell_id: &str, tx: &str, receipt_hash: &str) -> Result<()>

Appends a version: from tx on, cell_id has the value of receipt receipt_hash, which must be stored, of that cell and at that tx. tx must be later than the cell’s latest version (Error::NotLater).

fn version_asof(&self, cell_id: &str, asof: &str) -> Result<Option<Version>>

The cell’s latest version with tx <= asof.

fn versions(&self, cell_id: &str, from: &str, to: &str) -> Result<Vec<Version>>

The cell’s versions with from <= tx <= to, in tx order.

fn latest(&self, cell_id: &str) -> Result<Option<Version>>

The cell’s latest version.

fn dependents(&self, receipt_hash: &str) -> Result<Vec<String>>

The stored receipts that list receipt_hash among their inputs, by hash.

fn inputs(&self, receipt_hash: &str) -> Result<Vec<String>>

The inputs of a stored receipt, by hash (whether or not they are stored).

fn put_namespace( &self, host: &str, keydoc_bytes: &[u8], validated_at: &str, ) -> Result<()>

Records a host’s key document, checked as a 200 response for that host would be (SPEC 9.2, 9.3), validated at validated_at. Re-validation replaces the document; a validated_at earlier than the recorded one is Error::NotLater. Receipts already stored are not re-checked: they verified when they were stored (and putting one again stays idempotent).

fn namespace(&self, host: &str) -> Result<Option<Namespace>>

A host’s recorded key document.

fn bind_name(&self, fn_name: &str, fn_hash: &str, tx: &str) -> Result<()>

Appends a binding: from tx on, the fully qualified function name fn_name means fn_hash, whose descriptor must be stored. tx must be later than the name’s latest binding (Error::NotLater).

fn put_computed( &self, cell_id: &str, tx: &str, receipt_hash: &str, ) -> Result<()>

Records that receipt_hash (stored, a receipt of cell_id at tx) is a computed version of the cell. Insert-only, in any order (an older version may be added after a newer one): tx need not be later than anything. The version’s asof is the receipt’s. Idempotent for the same (cell_id, tx, asof, receipt_hash); another receipt for an existing (cell_id, tx, asof) is Error::Conflict (its hash is the receipt refused) and the stored one is kept. The receipt is checked as for put_version: Error::NotFound when it is not stored, Error::Mismatch when it is of another cell or at another tx. Since 0.2.0.

fn computed_asof(&self, cell_id: &str, asof: &str) -> Result<Option<Version>>

The computed version that answers as of asof: the one with the greatest asof <= asof (between equal asof, the greatest tx), or None. Since 0.2.0.

fn stored_asof(&self, cell_id: &str, asof: &str) -> Result<Option<Version>>

The stored version that answers as of asof: the latest version (by tx) with tx <= asof whose receipt’s asof is also <= asof, or None. A version whose receipt is late-signed (asof later than tx) answers only from its asof on; until then the version before it answers. (version_asof keeps its tx-only meaning.) Since 0.2.0.

fn cell_dependents(&self, cell_id: &str) -> Result<Vec<String>>

The cells that read cell_id: the cell ids of the stored receipts that list, among their inputs, any stored receipt of cell_id (lineage: edges joined to receipts). Ascending, each once. Since 0.2.0.

fn resolve_name(&self, fn_name: &str, asof: &str) -> Result<Option<String>>

The function hash fn_name meant as of asof.