Struct persy::Persy
[−]
[src]
pub struct Persy { /* fields omitted */ }
Main structure to manipolate persy storage files
Methods
impl Persy
[src]
fn create<P: Into<String>>(path: P) -> PRes<()>
[src]
fn open<P: Into<String>>(path: P, config: Config) -> PRes<Persy>
[src]
Open a database file.
The file should have been created with Persy::create
Errors
if the file does not exist fail.
fn begin(&self) -> PRes<Transaction>
[src]
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)?;
fn create_segment(&self, tx: &mut Transaction, segment: &str) -> PRes<()>
[src]
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)?;
fn drop_segment(&self, tx: &mut Transaction, segment: &str) -> PRes<()>
[src]
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)?;
fn exists_segment(&self, segment: &str) -> PRes<bool>
[src]
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")?);
fn exists_segment_tx(&self, tx: &Transaction, segment: &str) -> PRes<bool>
[src]
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")?);
fn insert_record(
&self,
tx: &mut Transaction,
segment: &str,
rec: &Vec<u8>
) -> PRes<PersyId>
[src]
&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)?;
fn read_record_tx(
&self,
tx: &mut Transaction,
segment: &str,
id: &PersyId
) -> PRes<Option<Vec<u8>>>
[src]
&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);
fn read_record(&self, segment: &str, id: &PersyId) -> PRes<Option<Vec<u8>>>
[src]
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);
fn scan_records_tx<'a>(
&'a self,
tx: &'a Transaction,
segment: &str
) -> PRes<RecordScannerTx<'a>>
[src]
&'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);
fn scan_records(&self, segment: &str) -> PRes<RecordScanner>
[src]
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);
fn update_record(
&self,
tx: &mut Transaction,
segment: &str,
id: &PersyId,
rec: &Vec<u8>
) -> PRes<()>
[src]
&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)?;
fn delete_record(
&self,
tx: &mut Transaction,
segment: &str,
id: &PersyId
) -> PRes<()>
[src]
&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)?;
fn rollback(&self, tx: Transaction) -> PRes<()>
[src]
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)?;
fn prepare_commit(&self, tx: Transaction) -> PRes<TransactionFinalize>
[src]
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)?;
fn rollback_prepared(&self, finalizer: TransactionFinalize) -> PRes<()>
[src]
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)?;
fn commit(&self, finalizer: TransactionFinalize) -> PRes<()>
[src]
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);