Struct persy::Persy

pub struct Persy { /* fields omitted */ }

Main structure to manipolate persy storage files

Methods

impl Persy

pub fn create<P: Into<String>>(path: P) -> PRes<()>

Create a new database file.

Errors

if the file already exist fail.

pub fn create_from_file(file: File) -> PRes<()>

Create a new database file.

Errors

if the file already exist fail.

pub fn open<P: Into<String>>(path: P, config: Config) -> PRes<Persy>

Open a database file.

The file should have been created with Persy::create

Errors

if the file does not exist fail.

pub fn open_with_recover<P: Into<String>, C>(
    path: P,
    config: Config,
    recover: C
) -> PRes<Persy> where
    C: Fn(&TransactionId) -> bool, 

Open a database file from a path with a recover function.

The file should have been created with Persy::create

Errors

if the file does not exist fail.

pub fn open_from_file(path: File, config: Config) -> PRes<Persy>

Open a database file from a direct file handle.

The file should have been created with Persy::create

Errors

if the file does not exist fail.

pub fn open_from_file_with_recover<C>(
    path: File,
    config: Config,
    recover: C
) -> PRes<Persy> where
    C: Fn(&TransactionId) -> bool, 

Open a database file, from a direct file handle and a transaction recover function.

The file should have been created with Persy::create

Errors

if the file does not exist fail.

pub fn begin(&self) -> PRes<Transaction>

Begin a new transaction.

The transaction isolation level is 'read_commited'. for commit call prepare_commit and commit

Example

let mut tx = persy.begin()?;
// ...
let prepared = persy.prepare_commit(tx)?;
persy.commit(prepared)?;

pub fn begin_id(&self, meta_id: TransactionId) -> PRes<Transaction>

Begin a new transaction specifying and id usable for crash recover.

The transaction isolation level is 'read_commited'. for commit call prepare_commit and commit

Example

let tx_id = vec![2;2];
let mut tx = persy.begin_id(tx_id)?;
// ...
let prepared = persy.prepare_commit(tx)?;
persy.commit(prepared)?;

pub fn create_segment(&self, tx: &mut Transaction, segment: &str) -> PRes<()>

Create a new segment with the provided name

Example

let mut tx = persy.begin()?;
persy.create_segment(&mut tx, "my_new_segment")?;
let prepared = persy.prepare_commit(tx)?;
persy.commit(prepared)?;

pub fn drop_segment(&self, tx: &mut Transaction, segment: &str) -> PRes<()>

Drop a existing segment

Example

let mut tx = persy.begin()?;
persy.drop_segment(&mut tx, "existing_segment_name")?;
let prepared = persy.prepare_commit(tx)?;
persy.commit(prepared)?;

pub fn exists_segment(&self, segment: &str) -> PRes<bool>

Check if a segment already exist in the storage

Example

let mut tx = persy.begin()?;
persy.create_segment(&mut tx, "my_new_segment")?;
let prepared = persy.prepare_commit(tx)?;
persy.commit(prepared)?;
assert!(persy.exists_segment("my_new_segment")?);

pub fn exists_segment_tx(&self, tx: &Transaction, segment: &str) -> PRes<bool>

Check if a segment already exist in the storage considering the transaction

Example

let mut tx = persy.begin()?;
persy.create_segment(&mut tx, "my_new_segment")?;
assert!(persy.exists_segment_tx(&mut tx, "my_new_segment")?);

pub fn insert_record(
    &self,
    tx: &mut Transaction,
    segment: &str,
    rec: &Vec<u8>
) -> PRes<PersyId>

create a new record

This function return an id that can be used by read_record and read_record_tx, the record content can be read only with the read_record_tx till the transacion is commited.

Expample

let mut tx = persy.begin()?;
let data = vec![1;20];
persy.insert_record(&mut tx, "seg", &data)?;
let prepared = persy.prepare_commit(tx)?;
persy.commit(prepared)?;

pub fn read_record_tx(
    &self,
    tx: &mut Transaction,
    segment: &str,
    id: &PersyId
) -> PRes<Option<Vec<u8>>>

Read the record content considering eventual in transaction changes.

Example

let mut tx = persy.begin()?;
let data = vec![1;20];
let id = persy.insert_record(&mut tx, "seg", &data)?;
let read = persy.read_record_tx(&mut tx, "seg", &id)?.expect("record exists");
assert_eq!(data,read);

pub fn read_record(&self, segment: &str, id: &PersyId) -> PRes<Option<Vec<u8>>>

Read the record content from persistent data.

Example

let mut tx = persy.begin()?;
let data = vec![1;20];
let id = persy.insert_record(&mut tx, "seg", &data)?;
let prepared = persy.prepare_commit(tx)?;
persy.commit(prepared)?;
let read = persy.read_record("seg", &id)?.expect("record exits");
assert_eq!(data,read);

pub fn scan_records_tx<'a>(
    &'a self,
    tx: &'a Transaction,
    segment: &str
) -> PRes<RecordScannerTx<'a>>

Scan for persistent and in transaction records

Example

let mut tx = persy.begin()?;
let data = vec![1;20];
let id = persy.insert_record(&mut tx, "seg", &data)?;
let mut count = 0;
for found in persy.scan_records_tx(&tx, "seg")? {
    println!("record size:{}",found.content.len());
    count+=1;
}
assert_eq!(count,1);

pub fn scan_records(&self, segment: &str) -> PRes<RecordScanner>

Scan a segment for persistent records

Example

let mut tx = persy.begin()?;
let data = vec![1;20];
let id = persy.insert_record(&mut tx, "seg", &data)?;
let prepared = persy.prepare_commit(tx)?;
persy.commit(prepared)?;
let mut count = 0;
for found in persy.scan_records("seg")? {
    println!("record size:{}",found.content.len());
    count+=1;
}
assert_eq!(count,1);

pub fn update_record(
    &self,
    tx: &mut Transaction,
    segment: &str,
    id: &PersyId,
    rec: &Vec<u8>
) -> PRes<()>

update the record content.

This updated content can be read only with the read_record_tx till the transacion is commited.

Example

let mut tx = persy.begin()?;
let data = vec![1;20];
let id = persy.insert_record(&mut tx, "seg", &data)?;
let new_data = vec![2;20];
persy.update_record(&mut tx, "seg", &id, &new_data)?;
let prepared = persy.prepare_commit(tx)?;
persy.commit(prepared)?;

pub fn delete_record(
    &self,
    tx: &mut Transaction,
    segment: &str,
    id: &PersyId
) -> PRes<()>

delete a record.

The record will result deleted only reading it whit read_record_tx till the transacion is commited.

Example

let mut tx = persy.begin()?;
let data = vec![1;20];
let id = persy.insert_record(&mut tx, "seg", &data)?;
persy.delete_record(&mut tx, "seg", &id)?;
let prepared = persy.prepare_commit(tx)?;
persy.commit(prepared)?;

pub fn rollback(&self, tx: Transaction) -> PRes<()>

Rollback a not yet prepared transaction.

All the resources used for eventual insert or update are released.

Example

let mut tx = persy.begin()?;
let data = vec![1;20];
persy.insert_record(&mut tx, "seg", &data)?;
persy.rollback(tx)?;

pub fn prepare_commit(&self, tx: Transaction) -> PRes<TransactionFinalize>

Prepare to commit a transaction, it will lock all the records involved in the transaction till a commit or rollback_prepared is called.

Example

let mut tx = persy.begin()?;
//Do what ever operations on the records
let data = vec![1;20];
persy.insert_record(&mut tx, "seg", &data)?;
let _= persy.prepare_commit(tx)?;

pub fn rollback_prepared(&self, finalizer: TransactionFinalize) -> PRes<()>

Rollback a prepared commit.

All the modification are rolled back and all the used resources are put released

Example

let mut tx = persy.begin()?;
//Do what ever operations on the records
let data = vec![1;20];
persy.insert_record(&mut tx, "seg", &data)?;
let prepared = persy.prepare_commit(tx)?;
persy.rollback_prepared(prepared)?;

pub fn commit(&self, finalizer: TransactionFinalize) -> PRes<()>

Finalize the commit result of a prepared commit.

All the operation done on the transaction are finalizated all the lock released, all the old resources are released for reuse.

Example

let mut tx = persy.begin()?;
let prepared = persy.prepare_commit(tx)?;
persy.commit(prepared);

Trait Implementations

impl Clone for Persy

fn clone(&self) -> Persy

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.