Could I get RecordBuf instead of Record from Query?

[Crispy13]

It seems that no API exists for that.

Could you make another Query for this?

[zaeleus]

Assuming alignment records, currently, you would convert format records to a buffer using RecordBuf::try_from_alignment_record, e.g.,

let records = reader.query(&header, &region)?.map(|result| {
    result.and_then(|record| RecordBuf::try_from_alignment_record(&header, &record))
});

[Crispy13]

Yes but benchmark showed it tooks about 2 x times for querying and converting them.

Making recordbuf from the start took about 1.2-3x times

[zaeleus]

To read into an existing RecordBuf, I would recommend manually composing a query reader with a BAM reader, e.g.,

main.rs

// cargo add [email protected] --features bam,core,csi,sam
// cargo add [email protected] --features libdeflate

use std::{env, io};

use noodles::{
    bam,
    core::{region::Interval, Region},
    csi,
    sam::{
        self,
        alignment::{io::Write, RecordBuf},
    },
};

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

    let src = args.nth(1).expect("missing src");
    let region: Region = args.next().expect("missing region").parse()?;

    let mut reader = bam::io::indexed_reader::Builder::default().build_from_path(src)?;
    let header = reader.read_header()?;

    let reference_sequence_id = header
        .reference_sequences()
        .get_index_of(region.name())
        .expect("invalid region name");
    let chunks = reader
        .index()
        .query(reference_sequence_id, region.interval())?;

    let mut decoder = reader.into_inner();
    let mut reader = bam::io::Reader::from(csi::io::Query::new(&mut decoder, chunks));

    let stdout = io::stdout().lock();
    let mut writer = sam::io::Writer::new(stdout);

    let mut record = RecordBuf::default();

    while reader.read_record_buf(&header, &mut record)? != 0 {
        if !intersects(&record, reference_sequence_id, region.interval()) {
            continue;
        }

        writer.write_alignment_record(&header, &record)?;
    }

    writer.finish(&header)?;

    Ok(())
}

fn intersects(record: &RecordBuf, reference_sequence_id: usize, region_interval: Interval) -> bool {
    match (
        record.reference_sequence_id(),
        record.alignment_start(),
        record.alignment_end(),
    ) {
        (Some(id), Some(start), Some(end)) => {
            let alignment_interval = (start..=end).into();
            id == reference_sequence_id && region_interval.intersects(alignment_interval)
        }
        _ => false,
    }
}

[Crispy13]

Thank you.
Is there any chance that what I said will be added?