Struct persy::Transaction[−][src]

pub struct Transaction { /* fields omitted */ }
Expand description

Transaction container, it include all the changes done in a transaction.

Implementations

Create a new segment with the provided name

Example

let mut tx = persy.begin()?;
tx.create_segment("my_new_segment")?;
tx.prepare()?.commit()?;

Drop a existing segment

Example

let mut tx = persy.begin()?;
tx.drop_segment("existing_segment_name")?;
tx.prepare()?.commit()?;

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

Example

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

Resolves the segment to a SegmentId, considering the transaction

Example

let mut tx = persy.begin()?;
tx.create_segment("my_new_segment")?;
let segment_id = tx.solve_segment_id("my_new_segment")?;

Resolves the index name to a IndexId, considering the transaction

Example

let mut tx = persy.begin()?;
tx.create_index::<u8,u8>("my_new_index", ValueMode::CLUSTER)?;
let segment_id = tx.solve_index_id("my_new_index")?;
👎 Deprecated:

use Transaction::insert instead

Create a new record.

This function return an id that can be used by read, the record content can be read only with the transaction read till the transaction is committed.

Example

let mut tx = persy.begin()?;
let data = vec![1;20];
tx.insert("seg", &data)?;
tx.prepare()?.commit()?;
👎 Deprecated:

use Transaction::read instead

Read the record content considering eventual in transaction changes.

Example

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

Scan for persistent and in transaction records

Example

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

use Transaction::update instead

Update the record content.

This updated content can be read only with the [transaction read] till the transaction is committed.

Example

let mut tx = persy.begin()?;
let data = vec![1;20];
let id = tx.insert("seg", &data)?;
let new_data = vec![2;20];
tx.update("seg", &id, &new_data)?;
👎 Deprecated:

use Transaction::delete instead

Delete a record.

The record will result deleted only reading it with transaction read till the transaction is committed.

Example

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

Create a new index with the name and the value management mode.

The create operation require two template arguments that are the types as keys and values of the index this have to match the following operation on the indexes.

Example

let mut tx = persy.begin()?;
tx.create_index::<u8,u8>("my_new_index", ValueMode::CLUSTER)?;

Drop an existing index.

Example

let mut tx = persy.begin()?;
tx.drop_index("my_new_index")?;

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

Example

let mut tx = persy.begin()?;
tx.create_index::<u8,u8>("my_new_index", ValueMode::REPLACE)?;
assert!(tx.exists_index("my_new_index")?);

Put a key value in an index following the value mode strategy.

Example

let mut tx = persy.begin()?;
tx.create_index::<u8,u8>("my_new_index", ValueMode::CLUSTER)?;
tx.put::<u8,u8>("my_new_index",10,10)?;
tx.prepare()?.commit()?;

Remove a key and optionally a specific value from an index following the value mode strategy.

Example

let mut tx = persy.begin()?;
tx.create_index::<u8,u8>("my_new_index", ValueMode::CLUSTER)?;
tx.put::<u8,u8>("my_new_index",10,10)?;
tx.remove::<u8,u8>("my_new_index",10,Some(10))?;

Get a value or a group of values from a key considering changes in transaction.

Example

tx.put::<u8,u8>("my_new_index",10,10)?;
let val = tx.get::<u8,u8>("my_new_index",&10)?;
if let Some(is_there) = val {
    // A value is actually there
    match is_there {
        Value::SINGLE(actual_value) => {
        },
        Value::CLUSTER(actual_value) => {
        },
    }
}

Browse a range of keys and values from an index including the transaction changes

Example

let persy = Persy::open("./data.persy",Config::new())?;
let mut tx = persy.begin()?;
tx.put::<u8,u8>("my_new_index",10,10)?;
{
    let iter:TxIndexIter<u8,u8> = tx.range("my_new_index",10..12)?;
    for (k,val) in iter  {
        // A value is actually there
        match val {
            Value::SINGLE(actual_value) => {
            },
            Value::CLUSTER(actual_value) => {
            },
        }
    }
}
tx.prepare()?.commit()?;

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];
tx.insert("seg", &data)?;
tx.rollback()?;
👎 Deprecated:

replaced by Transaction::prepare

Prepare to commit a transaction, when this method return all the validation checks are done and is guaranteed that the transaction can be committed successfully

it will lock all the records involved in the transaction till a commit or rollback is called.

Example

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

List all the existing segments, considering all the changes in transaction.

Example

let mut tx = persy.begin()?;
tx.create_segment("seg")?;
let segments = tx.list_segments()?;
let names = segments.into_iter().map(|(name,_id)|name).collect::<Vec<String>>();
assert!(names.contains(&"seg".to_string()));
tx.prepare()?.commit()?;

List all the existing indexes, considering changes in the transaction.

Example

let mut tx = persy.begin()?;
tx.create_index::<u8, u8>("idx", ValueMode::REPLACE)?;
let indexes = tx.list_indexes()?;
let names = indexes.into_iter().map(|(name,_id)|name).collect::<Vec<String>>();
assert!(names.contains(&"idx".to_string()));
tx.prepare()?.commit()?;

Trait Implementations

Executes the destructor for this type. Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Performs the conversion.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.