Struct SelectionExpression 

pub struct SelectionExpression { /* private fields */ }

A compiled selection expression — equivalent to recsel -e <expr>.

Implementations

impl SelectionExpression

pub fn compile(expr: &str, case_insensitive: bool) -> Result<Self, Error>

Examples found in repository

examples/query_records.rs (line 20)

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/modify_records.rs (line 25)

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 matches(&self, record: &RecordRef<'_>) -> bool

Examples found in repository

examples/query_records.rs (line 23)

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/modify_records.rs (line 40)

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 Drop for SelectionExpression

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.