Struct mz_stash::postgres::Stash

pub struct Stash {
    txn_mode: TransactionMode,
    config: Arc<Mutex<Config>>,
    schema: Option<String>,
    tls: MakeTlsConnector,
    client: Option<Client>,
    reconnect: Interval,
    statements: Option<PreparedStatements>,
    epoch: Option<NonZeroI64>,
    nonce: [u8; 16],
    pub(crate) sinces_tx: UnboundedSender<ConsolidateRequest>,
    pub(crate) collections: BTreeMap<String, i64>,
    metrics: Arc<Metrics>,
}

A Stash whose data is stored in a Postgres-compatible database. The format of the tables are not specified and should not be relied upon. The only promise is stability. Any changes to the table schemas will be accompanied by a clear migration path.

Fields

txn_mode: TransactionMode

config: Arc<Mutex<Config>>

schema: Option<String>

tls: MakeTlsConnector

client: Option<Client>

reconnect: Interval

statements: Option<PreparedStatements>

epoch: Option<NonZeroI64>

nonce: [u8; 16]

sinces_tx: UnboundedSender<ConsolidateRequest>

collections: BTreeMap<String, i64>

metrics: Arc<Metrics>

Implementations

impl Stash

pub async fn clear(url: &str, tls: MakeTlsConnector) -> Result<(), StashError>

Drops all tables associated with the stash if they exist. Only used in tests and benchmarks.

pub async fn with_debug_stash<F, T, Fut>(f: F) -> Result<T, StashError>where F: FnOnce(Stash) -> Fut, Fut: Future<Output = T>,

Creates a debug stash from the current COCKROACH_URL with a random schema, and DROPs it after f has returned.

pub async fn set_connect_timeout(&mut self, connect_timeout: Duration)

async fn connect(&mut self) -> Result<(), StashError>

Sets client to a new connection to the Postgres server.

pub(crate) async fn transact<F, T>(&mut self, f: F) -> Result<T, StashError>where F: for<'a> Fn(&'a CountedStatements<'a>, &'a Client, &'a BTreeMap<String, i64>) -> BoxFuture<'a, Result<T, StashError>>,

Construct a fenced transaction, which will cause this Stash to fail if another connection is opened to it. f may be called multiple times in a backoff-retry loop if the Postgres server is unavailable, so it should only call functions on its Transaction argument.

Examples

async fn x(&mut self) -> Result<(), StashError> {
    self.transact(move |stmts, tx| {
        Box::pin(async move {
            // Use tx.
        })
    })
    .await
 }

async fn transact_inner<F, T>( &mut self, f: &F ) -> Result<T, TransactionError<T>>where F: for<'a> Fn(&'a CountedStatements<'a>, &'a Client, &'a BTreeMap<String, i64>) -> BoxFuture<'a, Result<T, StashError>>,

async fn determine_commit( &mut self, committed_if_version: i64 ) -> Result<bool, StashError>

Reports whether a COMMIT that returned an error actually succeeded. An Err return from this function is retryable normally (if !err.is_unrecoverable()).

pub async fn is_initialized(&mut self) -> Result<bool, StashError>

Returns whether this Stash is initialized. We consider a Stash to be initialized if it contains an entry in the COLLECTION_CONFIG with the key of USER_VERSION_KEY.

pub async fn upgrade(&mut self) -> Result<(), StashError>

impl Stash

pub async fn collections(&mut self) -> Result<BTreeMap<i64, String>, StashError>

Returns a mapping from stash collection Id to stash collection name.

pub async fn confirm_leadership(&mut self) -> Result<(), StashError>

Returns Ok if the stash is the current leader and an error otherwise.

Note: This can be optimized to not increment the version, which is done automatically via with_commit. It will probably be more efficient to retry an in-determinate read-only transaction than relying on incrementing the version.

pub fn is_readonly(&self) -> bool

pub fn epoch(&self) -> Option<NonZeroI64>

impl Stash

pub async fn with_transaction<F, T>(&mut self, f: F) -> Result<T, StashError>where F: FnOnce(Transaction<'_>) -> BoxFuture<'_, Result<T, StashError>> + Clone + Sync + Send + 'static,

Transactionally executes closure f.

Trait Implementations

impl Debug for Stash

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

Formats the value using the given formatter.