Struct EseDb

pub struct EseDb { /* private fields */ }

A loaded instance of an ESE database.

Implementations

impl EseDb

pub fn open<P: AsRef<Path>>(filename: P) -> Result<Self>

Opens an existing ESE database file.

use libesedb::EseDb;
use std::io;

fn main() -> io::Result<()> {
    let db = EseDb::open("Catalog1.edb")?;
    // ...
    Ok(())
}

Examples found in repository

examples/fh-catalog-strings.rs (line 7)

fn main() {
    let filename = std::env::args()
        .nth(1)
        .unwrap_or("Catalog1.edb".to_string());
    let db = EseDb::open(filename).unwrap();
    println!("Db load finished!");
    let string = db.table_by_name("string").unwrap();
    for rec in string.iter_records().unwrap() {
        let rec = rec.unwrap();
        let vals = rec
            .iter_values()
            .unwrap()
            .map(|v| v.unwrap_or_default().to_string())
            .collect::<Vec<_>>();
        println!("{}", vals.join("\t"));
    }
}

examples/overview.rs (line 7)

fn main() {
    let filename = std::env::args()
        .nth(1)
        .expect("specify path to .esedb file");
    let db = EseDb::open(&filename).unwrap();
    println!("Database Overview ({}):", filename);
    for table in db.iter_tables().unwrap() {
        let table = table.unwrap();
        println!(
            "  {} [{:?}]",
            table.name().unwrap(),
            table
                .iter_columns()
                .unwrap()
                .map(|c| c.unwrap().name().unwrap())
                .collect::<Vec<String>>()
                .join(", "),
        );
        for record in table.iter_records().unwrap() {
            let record = record.unwrap();
            for i in 0..record.count_values().unwrap() {
                println!(
                    "  ├ T={:?} L={}, M={} V={:?}",
                    table.column(i).unwrap().variant().unwrap(),
                    record.is_long(i).unwrap(),
                    record.is_multi(i).unwrap(),
                    record.value(i).unwrap(),
                );
            }
        }
    }
}

pub fn as_mut_ptr(&mut self) -> *mut libesedb_table_t

Return underlying pointer for use with libesedb-sys.

pub fn table(&self, entry: i32) -> Result<Table<'_>>

Load a specific table by entry number. Returned Table is bound to the lifetime of the database.

pub fn table_by_name(&self, name: &str) -> Result<Table<'_>>

Load a specific table by name. Returned Table is bound to the lifetime of the database.

Examples found in repository

examples/fh-catalog-strings.rs (line 9)

fn main() {
    let filename = std::env::args()
        .nth(1)
        .unwrap_or("Catalog1.edb".to_string());
    let db = EseDb::open(filename).unwrap();
    println!("Db load finished!");
    let string = db.table_by_name("string").unwrap();
    for rec in string.iter_records().unwrap() {
        let rec = rec.unwrap();
        let vals = rec
            .iter_values()
            .unwrap()
            .map(|v| v.unwrap_or_default().to_string())
            .collect::<Vec<_>>();
        println!("{}", vals.join("\t"));
    }
}

pub fn count_tables(&self) -> Result<i32>

Total number of tables in ESE database.

pub fn iter_tables(&self) -> Result<impl Iterator<Item = Result<Table<'_>>>>

Create an iterator over all the tables in the database. The [IterEntries] iterator and the returned Tables are bound to the lifetime of the database.

for table in db.iter_tables()? {
    let table = table?;
    println!("{}", table.name()?);
}

Examples found in repository

examples/overview.rs (line 9)

fn main() {
    let filename = std::env::args()
        .nth(1)
        .expect("specify path to .esedb file");
    let db = EseDb::open(&filename).unwrap();
    println!("Database Overview ({}):", filename);
    for table in db.iter_tables().unwrap() {
        let table = table.unwrap();
        println!(
            "  {} [{:?}]",
            table.name().unwrap(),
            table
                .iter_columns()
                .unwrap()
                .map(|c| c.unwrap().name().unwrap())
                .collect::<Vec<String>>()
                .join(", "),
        );
        for record in table.iter_records().unwrap() {
            let record = record.unwrap();
            for i in 0..record.count_values().unwrap() {
                println!(
                    "  ├ T={:?} L={}, M={} V={:?}",
                    table.column(i).unwrap().variant().unwrap(),
                    record.is_long(i).unwrap(),
                    record.is_multi(i).unwrap(),
                    record.value(i).unwrap(),
                );
            }
        }
    }
}

Trait Implementations

impl Drop for EseDb

fn drop(&mut self)

Executes the destructor for this type.