Struct Query 

pub struct Query<'store> { /* private fields */ }

Implementations

impl<'store> Query<'store>

pub fn documents<F>(self, f: F) -> Self

where F: Fn(&Document) -> bool + 'store,

Skip documents for which predicate returns false.

Use this to leverage zone-map statistics before scanning blocks:

store.query()
    .documents(|doc| doc.zone_maps.code_languages.contains("python"));

pub fn under_heading( self, content: impl Into<String>, depth: Option<u8>, ) -> Self

Restrict results to blocks that fall within the heading section identified by content and optional depth.

Equivalent to the SQL WHERE b UNDER (SELECT id FROM blocks WHERE ...).

For best performance, chain a .documents(|d| d.zone_maps.heading_contents.contains("...")) filter before this to skip irrelevant documents via zone maps.

pub fn under_interval(self, pre: u32, post: u32) -> Self

Restrict results to blocks that fall within the interval (pre, post).

Use this when you already know the ancestor block’s interval values.

pub fn filter<F>(self, f: F) -> Self

where F: Fn(&Block) -> bool + 'store,

Keep only blocks for which predicate returns true.

pub fn block_type(self, ty: BlockType) -> Self

Keep only blocks with the given BlockType.

pub fn heading_depth(self, depth: u8) -> Self

Keep only heading blocks at the given depth.

pub fn code_lang(self, lang: impl Into<String>) -> Self

Keep only code blocks with the given language tag.

pub fn content_contains(self, substring: impl Into<String>) -> Self

Keep only blocks whose content contains substring (case-sensitive).

pub fn content_contains_ci(self, pattern: impl Into<String>) -> Self

Keep only blocks whose content matches pattern (case-insensitive).

pub fn limit(self, n: usize) -> Self

Stop collecting after n results.

pub fn collect(&self) -> Vec<QueryResult<'_>>

Execute the query, returning matched (block, document) pairs in document order.

pub fn blocks(&self) -> Vec<Block>

Like [collect], but returns cloned blocks (discarding document context).

Returns owned Vec<Block> so it can be used on temporaries:

let blocks = store.query().heading_depth(1).blocks();
assert_eq!(blocks.len(), 1);

pub fn count(&self) -> usize

Returns the number of matching blocks without materialising them.

pub fn lint_heading_followed_by( &self, heading_depth: u8, forbidden_types: &[BlockType], ) -> Vec<LintViolation<'_>>

Find all (heading, next_sibling) pairs where the heading matches the given depth and the immediately following sibling has one of the forbidden_types.

This is the foundation for structural lint rules such as:

“An H2 heading must not be immediately followed by a list.”

Example

use mq_db::{DocumentStore, block::BlockType};

let mut store = DocumentStore::new();
store.add_str("## Section\n\n- item\n").unwrap();

let q = store.query();
let violations = q.lint_heading_followed_by(2, &[BlockType::List]);

assert_eq!(violations.len(), 1);