Struct Db 

pub struct Db { /* private fields */ }

Implementations

impl Db

pub fn new() -> Self

Allocate an empty database. Use Db::append_rset to add record sets before serializing via Db::to_rec_string.

Examples found in repository

examples/write_rec.rs (line 10)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut db = Db::new();

    let mut rset = OwnedRset::new();

    let mut descriptor = Record::new();
    descriptor.append_field("%rec", "Book")?;
    descriptor.append_field("%type", "Year int")?;
    descriptor.append_field("%mandatory", "Title")?;
    rset.set_descriptor(descriptor);

    for (title, author, year) in [
        ("Refactoring", "Martin Fowler", "1999"),
        ("Domain-Driven Design", "Eric Evans", "2003"),
        ("Test-Driven Development", "Kent Beck", "2002"),
    ] {
        let mut record = Record::new();
        record.append_field("Title", title)?;
        record.append_field("Author", author)?;
        record.append_field("Year", year)?;
        rset.append_record(record)?;
    }

    db.append_rset(rset)?;
    println!("{}", db.to_rec_string()?);
    Ok(())
}

pub fn parse_str(text: &str) -> Result<Self, Error>

Examples found in repository

examples/count_records.rs (line 9)

fn main() {
    let path = std::env::args().nth(1).expect("usage: count_records <file.rec>");
    let text = fs::read_to_string(&path).expect("read file");

    let mut db = Db::parse_str(&text).expect("parse");
    let n_rsets = db.num_rsets();
    let total: usize = (0..n_rsets)
        .map(|i| db.rset_at(i).expect("rset by index").num_records())
        .sum();
    println!("{}: {} records across {} record set(s)", path, total, n_rsets);
}

examples/query_records.rs (line 14)

fn main() {
    let mut args = std::env::args().skip(1);
    let path = args
        .next()
        .expect("usage: query_records <file.rec> <Type> <selection-expression>");
    let rset_type = args.next().expect("missing record type");
    let expr = args.next().expect("missing selection expression");

    let text = fs::read_to_string(&path).expect("read file");
    let mut db = Db::parse_str(&text).expect("parse");

    let rset = db
        .rset_by_type(&rset_type)
        .unwrap_or_else(|| panic!("no record set of type {rset_type:?}"));
    let selection_expression =
        SelectionExpression::compile(&expr, false).expect("compile selection expression");

    let mut matches = 0usize;
    for record in rset.records().filter(|r| selection_expression.matches(r)) {
        matches += 1;
        for field in record.fields() {
            println!("{}: {}", field.name(), field.value());
        }
        println!();
    }
    eprintln!("{matches} match(es)");
}

examples/append_record.rs (line 20)

fn main() {
    let mut args = std::env::args().skip(1);
    let path = args
        .next()
        .expect("usage: append_record <file.rec> <Type> Field=Value [Field=Value ...]");
    let rset_type = args.next().expect("missing record type");
    let pairs: Vec<(String, String)> = args
        .map(|a| {
            let (k, v) = a.split_once('=').expect("expected Field=Value");
            (k.to_string(), v.to_string())
        })
        .collect();
    assert!(!pairs.is_empty(), "need at least one Field=Value");

    let text = fs::read_to_string(&path).expect("read file");
    let mut db = Db::parse_str(&text).expect("parse");

    let mut record = Record::new();
    for (k, v) in &pairs {
        record.append_field(k, v).expect("append field");
    }

    {
        let mut rset = db
            .rset_by_type(&rset_type)
            .unwrap_or_else(|| panic!("no record set of type {rset_type:?}"));
        rset.append_record(record).expect("append record");
    }

    let serialized = db.to_rec_string().expect("serialize");
    fs::write(&path, serialized).expect("write file");
    println!("appended 1 record to rset {rset_type:?} in {path}");
}

examples/modify_records.rs (line 23)

fn main() -> ExitCode {
    let mut args = std::env::args().skip(1);
    let path = args.next().unwrap_or_else(|| usage());
    let rset_type = args.next().unwrap_or_else(|| usage());
    let expr = args.next().unwrap_or_else(|| usage());
    let action = args.next().unwrap_or_else(|| usage());

    let text = fs::read_to_string(&path).expect("read file");
    let mut db = Db::parse_str(&text).expect("parse");
    let selection_expression =
        SelectionExpression::compile(&expr, false).expect("compile selection expression");

    let summary = {
        let mut rset = db
            .rset_by_type(&rset_type)
            .unwrap_or_else(|| panic!("no record set of type {rset_type:?}"));

        match action.as_str() {
            "set" => {
                let pair = args.next().unwrap_or_else(|| usage());
                let (field, value) = pair
                    .split_once('=')
                    .unwrap_or_else(|| panic!("expected Field=Value, got {pair:?}"));
                let mut updated = 0usize;
                let mut missing = 0usize;
                for mut record in rset.records().filter(|r| selection_expression.matches(r)) {
                    match record.set_field(field, value).expect("set field") {
                        true => updated += 1,
                        false => missing += 1,
                    }
                }
                format!(
                    "set {field}={value} on {updated} record(s); {missing} matching record(s) had no such field"
                )
            }
            "delete" => {
                let removed = rset.remove_matching(|r| selection_expression.matches(r));
                format!("deleted {removed} record(s)")
            }
            other => {
                eprintln!("unknown action {other:?}");
                return ExitCode::from(2);
            }
        }
    };

    let serialized = db.to_rec_string().expect("serialize");
    fs::write(&path, serialized).expect("write file");
    println!("{summary}");
    ExitCode::SUCCESS
}

pub fn num_rsets(&self) -> usize

Examples found in repository

examples/count_records.rs (line 10)

fn main() {
    let path = std::env::args().nth(1).expect("usage: count_records <file.rec>");
    let text = fs::read_to_string(&path).expect("read file");

    let mut db = Db::parse_str(&text).expect("parse");
    let n_rsets = db.num_rsets();
    let total: usize = (0..n_rsets)
        .map(|i| db.rset_at(i).expect("rset by index").num_records())
        .sum();
    println!("{}: {} records across {} record set(s)", path, total, n_rsets);
}

pub fn rset_at(&mut self, idx: usize) -> Option<Rset<'_>>

Examples found in repository

examples/count_records.rs (line 12)

fn main() {
    let path = std::env::args().nth(1).expect("usage: count_records <file.rec>");
    let text = fs::read_to_string(&path).expect("read file");

    let mut db = Db::parse_str(&text).expect("parse");
    let n_rsets = db.num_rsets();
    let total: usize = (0..n_rsets)
        .map(|i| db.rset_at(i).expect("rset by index").num_records())
        .sum();
    println!("{}: {} records across {} record set(s)", path, total, n_rsets);
}

pub fn rset_by_type(&mut self, name: &str) -> Option<Rset<'_>>

Examples found in repository

examples/query_records.rs (line 17)

fn main() {
    let mut args = std::env::args().skip(1);
    let path = args
        .next()
        .expect("usage: query_records <file.rec> <Type> <selection-expression>");
    let rset_type = args.next().expect("missing record type");
    let expr = args.next().expect("missing selection expression");

    let text = fs::read_to_string(&path).expect("read file");
    let mut db = Db::parse_str(&text).expect("parse");

    let rset = db
        .rset_by_type(&rset_type)
        .unwrap_or_else(|| panic!("no record set of type {rset_type:?}"));
    let selection_expression =
        SelectionExpression::compile(&expr, false).expect("compile selection expression");

    let mut matches = 0usize;
    for record in rset.records().filter(|r| selection_expression.matches(r)) {
        matches += 1;
        for field in record.fields() {
            println!("{}: {}", field.name(), field.value());
        }
        println!();
    }
    eprintln!("{matches} match(es)");
}

examples/append_record.rs (line 29)

fn main() {
    let mut args = std::env::args().skip(1);
    let path = args
        .next()
        .expect("usage: append_record <file.rec> <Type> Field=Value [Field=Value ...]");
    let rset_type = args.next().expect("missing record type");
    let pairs: Vec<(String, String)> = args
        .map(|a| {
            let (k, v) = a.split_once('=').expect("expected Field=Value");
            (k.to_string(), v.to_string())
        })
        .collect();
    assert!(!pairs.is_empty(), "need at least one Field=Value");

    let text = fs::read_to_string(&path).expect("read file");
    let mut db = Db::parse_str(&text).expect("parse");

    let mut record = Record::new();
    for (k, v) in &pairs {
        record.append_field(k, v).expect("append field");
    }

    {
        let mut rset = db
            .rset_by_type(&rset_type)
            .unwrap_or_else(|| panic!("no record set of type {rset_type:?}"));
        rset.append_record(record).expect("append record");
    }

    let serialized = db.to_rec_string().expect("serialize");
    fs::write(&path, serialized).expect("write file");
    println!("appended 1 record to rset {rset_type:?} in {path}");
}

examples/modify_records.rs (line 29)

fn main() -> ExitCode {
    let mut args = std::env::args().skip(1);
    let path = args.next().unwrap_or_else(|| usage());
    let rset_type = args.next().unwrap_or_else(|| usage());
    let expr = args.next().unwrap_or_else(|| usage());
    let action = args.next().unwrap_or_else(|| usage());

    let text = fs::read_to_string(&path).expect("read file");
    let mut db = Db::parse_str(&text).expect("parse");
    let selection_expression =
        SelectionExpression::compile(&expr, false).expect("compile selection expression");

    let summary = {
        let mut rset = db
            .rset_by_type(&rset_type)
            .unwrap_or_else(|| panic!("no record set of type {rset_type:?}"));

        match action.as_str() {
            "set" => {
                let pair = args.next().unwrap_or_else(|| usage());
                let (field, value) = pair
                    .split_once('=')
                    .unwrap_or_else(|| panic!("expected Field=Value, got {pair:?}"));
                let mut updated = 0usize;
                let mut missing = 0usize;
                for mut record in rset.records().filter(|r| selection_expression.matches(r)) {
                    match record.set_field(field, value).expect("set field") {
                        true => updated += 1,
                        false => missing += 1,
                    }
                }
                format!(
                    "set {field}={value} on {updated} record(s); {missing} matching record(s) had no such field"
                )
            }
            "delete" => {
                let removed = rset.remove_matching(|r| selection_expression.matches(r));
                format!("deleted {removed} record(s)")
            }
            other => {
                eprintln!("unknown action {other:?}");
                return ExitCode::from(2);
            }
        }
    };

    let serialized = db.to_rec_string().expect("serialize");
    fs::write(&path, serialized).expect("write file");
    println!("{summary}");
    ExitCode::SUCCESS
}

pub fn append_rset(&mut self, rset: OwnedRset) -> Result<(), Error>

Append an OwnedRset to the end of the database. Ownership of the rset transfers to librec; the rset will be freed when this Db is dropped.

Examples found in repository

examples/write_rec.rs (line 32)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut db = Db::new();

    let mut rset = OwnedRset::new();

    let mut descriptor = Record::new();
    descriptor.append_field("%rec", "Book")?;
    descriptor.append_field("%type", "Year int")?;
    descriptor.append_field("%mandatory", "Title")?;
    rset.set_descriptor(descriptor);

    for (title, author, year) in [
        ("Refactoring", "Martin Fowler", "1999"),
        ("Domain-Driven Design", "Eric Evans", "2003"),
        ("Test-Driven Development", "Kent Beck", "2002"),
    ] {
        let mut record = Record::new();
        record.append_field("Title", title)?;
        record.append_field("Author", author)?;
        record.append_field("Year", year)?;
        rset.append_record(record)?;
    }

    db.append_rset(rset)?;
    println!("{}", db.to_rec_string()?);
    Ok(())
}

pub fn to_rec_string(&self) -> Result<String, Error>

Examples found in repository

examples/write_rec.rs (line 33)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut db = Db::new();

    let mut rset = OwnedRset::new();

    let mut descriptor = Record::new();
    descriptor.append_field("%rec", "Book")?;
    descriptor.append_field("%type", "Year int")?;
    descriptor.append_field("%mandatory", "Title")?;
    rset.set_descriptor(descriptor);

    for (title, author, year) in [
        ("Refactoring", "Martin Fowler", "1999"),
        ("Domain-Driven Design", "Eric Evans", "2003"),
        ("Test-Driven Development", "Kent Beck", "2002"),
    ] {
        let mut record = Record::new();
        record.append_field("Title", title)?;
        record.append_field("Author", author)?;
        record.append_field("Year", year)?;
        rset.append_record(record)?;
    }

    db.append_rset(rset)?;
    println!("{}", db.to_rec_string()?);
    Ok(())
}

examples/append_record.rs (line 34)

fn main() {
    let mut args = std::env::args().skip(1);
    let path = args
        .next()
        .expect("usage: append_record <file.rec> <Type> Field=Value [Field=Value ...]");
    let rset_type = args.next().expect("missing record type");
    let pairs: Vec<(String, String)> = args
        .map(|a| {
            let (k, v) = a.split_once('=').expect("expected Field=Value");
            (k.to_string(), v.to_string())
        })
        .collect();
    assert!(!pairs.is_empty(), "need at least one Field=Value");

    let text = fs::read_to_string(&path).expect("read file");
    let mut db = Db::parse_str(&text).expect("parse");

    let mut record = Record::new();
    for (k, v) in &pairs {
        record.append_field(k, v).expect("append field");
    }

    {
        let mut rset = db
            .rset_by_type(&rset_type)
            .unwrap_or_else(|| panic!("no record set of type {rset_type:?}"));
        rset.append_record(record).expect("append record");
    }

    let serialized = db.to_rec_string().expect("serialize");
    fs::write(&path, serialized).expect("write file");
    println!("appended 1 record to rset {rset_type:?} in {path}");
}

examples/modify_records.rs (line 61)

fn main() -> ExitCode {
    let mut args = std::env::args().skip(1);
    let path = args.next().unwrap_or_else(|| usage());
    let rset_type = args.next().unwrap_or_else(|| usage());
    let expr = args.next().unwrap_or_else(|| usage());
    let action = args.next().unwrap_or_else(|| usage());

    let text = fs::read_to_string(&path).expect("read file");
    let mut db = Db::parse_str(&text).expect("parse");
    let selection_expression =
        SelectionExpression::compile(&expr, false).expect("compile selection expression");

    let summary = {
        let mut rset = db
            .rset_by_type(&rset_type)
            .unwrap_or_else(|| panic!("no record set of type {rset_type:?}"));

        match action.as_str() {
            "set" => {
                let pair = args.next().unwrap_or_else(|| usage());
                let (field, value) = pair
                    .split_once('=')
                    .unwrap_or_else(|| panic!("expected Field=Value, got {pair:?}"));
                let mut updated = 0usize;
                let mut missing = 0usize;
                for mut record in rset.records().filter(|r| selection_expression.matches(r)) {
                    match record.set_field(field, value).expect("set field") {
                        true => updated += 1,
                        false => missing += 1,
                    }
                }
                format!(
                    "set {field}={value} on {updated} record(s); {missing} matching record(s) had no such field"
                )
            }
            "delete" => {
                let removed = rset.remove_matching(|r| selection_expression.matches(r));
                format!("deleted {removed} record(s)")
            }
            other => {
                eprintln!("unknown action {other:?}");
                return ExitCode::from(2);
            }
        }
    };

    let serialized = db.to_rec_string().expect("serialize");
    fs::write(&path, serialized).expect("write file");
    println!("{summary}");
    ExitCode::SUCCESS
}

Trait Implementations

impl Default for Db

fn default() -> Self

Returns the “default value” for a type.

impl Drop for Db

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.