Struct db_core::instance::Instance

pub struct Instance { /* fields omitted */ }

Instance provides interface for the client to interact with the system: initiate and complete transaction, write and read data, etc.

Implementations

impl Instance

pub fn new(conf: ConfigMt) -> Result<Instance, Error>

Create a new instance with given configuration.

pub fn initialize_datastore(
    path: &str,
    block_size: usize,
    desc_set: &[FileDesc]
) -> Result<(), Error>

Initialize datastore: create data, checkpoint, versioning store files, and lock file.

pub fn add_datafile(
    &self,
    file_type: FileType,
    extent_size: u16,
    extent_num: u16,
    max_extent_num: u16
) -> Result<u16, Error>

Add a new file to datastore and return it’s file_id.

pub fn begin_transaction(&self) -> Result<Transaction<'_>, Error>

Begin a new transaction.

pub fn commit(&self, t: Transaction<'_>) -> Result<(), Error>

Commit transaction.

pub fn rollback(&self, t: Transaction<'_>) -> Result<(), Error>

Rollback transaction.

pub fn open_read(
    &self,
    obj_id: &ObjectId,
    t: &Transaction<'_>
) -> Result<Object<'_>, Error>

Open an existing object for read. After object is opened it is possible to read and seek through object’s data.

pub fn open_write<'a>(
    &'a self,
    obj_id: &ObjectId,
    t: &'a mut Transaction<'_>,
    timeout: i64
) -> Result<ObjectWrite<'_>, Error>

Open an existing object for modification by its id. After object is opened it is possible to read, write and seek through object data. This operation puts lock on the object which is released after transaction commit or rollback. If timeout is -1 then wait indefinitely, otherwise wait for requested time in ms before returning error, or until transaction holding lock on the object has finished.

pub fn open_create<'a>(
    &'a self,
    file_id: u16,
    t: &'a mut Transaction<'_>,
    initial_size: usize
) -> Result<ObjectWrite<'_>, Error>

Create a new object and open it for write. After object is opened it is possible to read, write and seek object data. This operation puts lock on the object which is released after transaction commit or rollback.

pub fn delete(
    &self,
    obj_id: &ObjectId,
    t: &mut Transaction<'_>,
    timeout: i64
) -> Result<(), Error>

Delete an object. If object is in use, timeout can be specified, and current transaction will wait given time until transaction holding the lock on the object has finished.

pub fn from_shared_state(ss: InstanceSharedState) -> Result<Self, Error>

Build instance using shared state.

pub fn get_shared_state(&self) -> Result<InstanceSharedState, Error>

Return shared state that can be shared between threads.

pub fn terminate(self)

Terminate the instance. If several instances are running and sharing state then function has no effect for any of them but the last one. It is up to client to make sure all transactions are finished, otherwise unfinished transactions will be rolled back on the next start.