Struct SparqlQueryContext 

#[repr(C)]
pub struct SparqlQueryContext {
    pub patterns: [Pattern; 128],
    pub pattern_count: usize,
    pub expressions: [Expression; 128],
    pub expression_count: usize,
    pub paths: [Path; 128],
    pub path_count: usize,
    pub subqueries: [SparqlQuery; 16],
    pub subquery_count: usize,
    pub variable_hashes: [u64; 16],
    pub variable_count: usize,
    pub function_args: [ExpressionId; 64],
    pub function_arg_count: usize,
}

Flat query context arena - pre-allocated, no heap allocation

Fields

patterns: [Pattern; 128]

Flat array of all patterns in the query

pattern_count: usize

Number of patterns currently allocated

expressions: [Expression; 128]

Flat array of all expressions in the query

expression_count: usize

Number of expressions currently allocated

paths: [Path; 128]

Flat array of all property paths in the query

path_count: usize

Number of paths currently allocated

subqueries: [SparqlQuery; 16]

Flat array of subqueries (for nested queries)

subquery_count: usize

Number of subqueries currently allocated

variable_hashes: [u64; 16]

Variable name to ID mapping (simplified - stores as hash for now)

variable_count: usize

Number of variables

function_args: [ExpressionId; 64]

Argument storage for function calls (flat array)

function_arg_count: usize

Number of function args

Implementations

impl SparqlQueryContext

pub fn new() -> Self

pub fn alloc_pattern(&mut self, pattern: Pattern) -> Result<PatternId, String>

Allocate a new pattern, returns its ID

pub fn alloc_expression( &mut self, expr: Expression, ) -> Result<ExpressionId, String>

Allocate a new expression, returns its ID

pub fn alloc_path(&mut self, path: Path) -> Result<PathId, String>

Allocate a new property path, returns its ID

pub fn alloc_subquery(&mut self, query: SparqlQuery) -> Result<u16, String>

Allocate a new subquery, returns its ID

pub fn register_variable(&mut self, name: &str) -> Result<VariableId, String>

Register a variable name, returns its ID

pub fn reset(&mut self)

Reset the context for reuse (clears all allocations)

Trait Implementations

impl Default for SparqlQueryContext

fn default() -> Self

Returns the “default value” for a type.