Struct Store 

pub struct Store { /* private fields */ }

Implementations

impl Store

pub fn open(path: &str) -> Result<Store>

Open a store at the supplied path, ensuring that it includes the bootstrap schema.

pub fn transact(&mut self, transaction: &str) -> Result<TxReport>

pub fn expand_tx_fns(&mut self, transaction: &str) -> Result<String>

Prepare transaction for the transactor: replace every invocation of a user-defined transaction function ([:my/fn arg ...] on an ident that carries :db/fn) with the tx-data it returns, and define the :db/fn attribute itself the first time a transaction installs a function. Store::transact and Store::with_speculative call this; a host that drives InProgress::transact directly calls it first.

Functions run in the sandboxed mino interpreter (mino feature), see the database as of the start of the transaction, and nest at most MENTAT_TXFN_MAX_DEPTH (default 16) deep. Without the mino feature only the :db/fn attribute bootstrap applies.

pub fn with_speculative(&mut self, transaction: &str) -> Result<TxReport>

Speculatively transact transaction and return its TxReport WITHOUT committing (Datomic d/with). Delegates to Conn::transact_speculative, which opens a real SQLite transaction and rolls it back on drop, so the store is left unchanged. This is the thin &mut Store wrapper the scripting layer needs, since transact_speculative lives on Conn and wants both the Conn and the rusqlite::Connection (both private here).

impl Store

pub fn sqlite_mut(&mut self) -> &mut Connection

Intended for use from tests.

pub fn sqlite_ref(&self) -> &Connection

A shared borrow of the underlying SQLite connection, for read-only helpers (e.g. mentat_db::debug::datoms) that only need &Connection.

impl Store

pub fn dismantle(self) -> (Connection, Conn)

pub fn conn(&self) -> &Conn

pub fn begin_read(&mut self) -> Result<InProgressRead<'_, '_>>

pub fn begin_transaction(&mut self) -> Result<InProgress<'_, '_>>

pub fn cache(&mut self, attr: &Keyword, direction: CacheDirection) -> Result<()>

pub fn register_observer(&mut self, key: String, observer: Arc<TxObserver>)

pub fn unregister_observer(&mut self, key: &str)

pub fn last_tx_id(&self) -> Entid

pub fn set_auto_index(&mut self, mode: AutoIndex)

How mentat manages secondary indexes for this Store (see AutoIndex). The default comes from MENTAT_AUTO_INDEX (off/schema/adaptive), else Schema.

pub fn set_index_tuning(&mut self, min_uses: u32, idle: Duration)

Adaptive thresholds: create an index once an attribute is value-filtered by min_uses queries within one tuning period; drop a mentat-created index unused for a whole period and for at least idle.

pub fn tune_indexes(&mut self, dry_run: bool) -> Result<Vec<IndexAction>>

Apply (or, with dry_run, only report) index changes per the current AutoIndex mode. Only ever drops indexes mentat created (listed in mentat_managed_indexes).

pub fn q_once_as_of<T>( &self, query: &str, inputs: T, tx: Entid, ) -> Result<QueryOutput>

where T: Into<Option<QueryInputs>>,

Run a Datalog query against a historical basis reconstructed as of transaction tx (inclusive) – the state that was current at tx.

pub fn q_explain_temporal<T>( &self, query: &str, inputs: T, temporal: Option<TemporalBound>, ) -> Result<QueryExplanation>

where T: Into<Option<QueryInputs>>,

EXPLAIN QUERY PLAN for a query, optionally against a historical basis.

pub fn q_once_since<T>( &self, query: &str, inputs: T, tx: Entid, ) -> Result<QueryOutput>

where T: Into<Option<QueryInputs>>,

Run a Datalog query seeing only datoms transacted after transaction tx (since). Typically used with a history pattern [?e ?a ?v ?tx ?added].

Trait Implementations

impl Pullable for Store

fn pull_attributes_for_entities<E, A>( &self, entities: E, attributes: A, ) -> Result<BTreeMap<Entid, ValueRc<StructuredMap>>>

where E: IntoIterator<Item = Entid>, A: IntoIterator<Item = Entid>,

fn pull_attributes_for_entity<A>( &self, entity: Entid, attributes: A, ) -> Result<StructuredMap>

where A: IntoIterator<Item = Entid>,

impl Queryable for Store

fn q_once<T>(&self, query: &str, inputs: T) -> Result<QueryOutput>

where T: Into<Option<QueryInputs>>,

fn q_prepare<T>(&self, query: &str, inputs: T) -> PreparedResult<'_>

where T: Into<Option<QueryInputs>>,

fn q_explain<T>(&self, query: &str, inputs: T) -> Result<QueryExplanation>

where T: Into<Option<QueryInputs>>,

fn lookup_values_for_attribute<E>( &self, entity: E, attribute: &Keyword, ) -> Result<Vec<TypedValue>>

where E: Into<Entid>,

fn lookup_value_for_attribute<E>( &self, entity: E, attribute: &Keyword, ) -> Result<Option<TypedValue>>

where E: Into<Entid>,