Struct ParsedQuery 

pub struct ParsedQuery {
    pub ast: Arc<Query>,
    pub repo_filter: RepoFilter,
    pub normalized: Arc<str>,
}

Canonical parsed query representation

Contains the boolean query AST, extracted repo filter, and normalized query string for cache key generation.

Example

use sqry_core::query::QueryExecutor;

let executor = QueryExecutor::new();
let parsed = executor.parse_query_ast("repo:backend-* AND kind:function")?;

// AST contains the boolean expression (without repo predicates)
let ast = &parsed.ast;

// Repo filter extracted for workspace/multi-repo filtering
let repo_filter = &parsed.repo_filter;

// Normalized string used for cache keys (repo predicates stripped)
let cache_key_string = &parsed.normalized;

Fields

ast: Arc<Query>

Parsed boolean query AST (Arc-wrapped for zero-copy sharing)

This AST represents the query after:

• Lexing and parsing
• Validation against field registry
• Optimization (if enabled)
• Repo predicate extraction (repo conditions removed from AST)

repo_filter: RepoFilter

Extracted repository filter

Compiled from repo: predicates in the original query. Used by workspace and session managers to filter repositories before executing the query.

Empty filter matches all repositories.

normalized: Arc<str>

Normalized query string (repo predicates stripped)

Used for cache key generation. By stripping repo predicates, we improve cache hit rates across different repo filters.

Example:

• Input: “repo:backend-* AND kind:function AND name:test”
• Normalized: “kind:function AND name:test”

Arc<str> provides zero-copy sharing in cache keys.

Implementations

impl ParsedQuery

pub fn new( ast: Arc<QueryAST>, repo_filter: RepoFilter, normalized: String, ) -> Self

Create a new ParsedQuery

Arguments

• ast - Parsed boolean query AST
• repo_filter - Extracted repository filter
• normalized - Normalized query string (repo predicates stripped)

pub fn from_ast(ast: Arc<QueryAST>) -> Result<Self>

Create ParsedQuery from an AST

This is a convenience method that:

1. Extracts repo filter from AST
2. Strips repo predicates to create normalized AST
3. Serializes normalized AST to string for cache key

Arguments

• ast - Parsed boolean query AST (Arc-wrapped)

Returns

• Ok(ParsedQuery) - Successfully created ParsedQuery
• Err(...) - Failed to extract repo filter or normalize AST

Example

use sqry_core::query::{QueryParser, ParsedQuery};
use std::sync::Arc;

let ast = QueryParser::parse_query("kind:function AND name:test")?;
let parsed = ParsedQuery::from_ast(Arc::new(ast))?;

Errors

Returns anyhow::Error when repo filter extraction or normalization fails.

pub fn ast(&self) -> &Arc<QueryAST>

Get a reference to the AST

pub fn repo_filter(&self) -> &RepoFilter

Get a reference to the repo filter

pub fn normalized(&self) -> &str

Get the normalized query string

Trait Implementations

impl Clone for ParsedQuery

fn clone(&self) -> ParsedQuery

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ParsedQuery

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.