Struct GenerateExecutor 

pub struct GenerateExecutor {
    pub query: GenerateQuery,
}

Executes a parsed GenerateQuery over a set of SPARQL variable bindings.

Example

use std::collections::HashMap;
use oxirs_arq::generate::{GenerateExecutor, Bindings, GenerateQuery, TemplateClause, GenerateLiteral};

let clause = TemplateClause {
    prefix: Some("name=".to_string()),
    expr: GenerateLiteral::Var("name".to_string()),
    suffix: None,
};
let query = GenerateQuery::new(vec![clause], "?s foaf:name ?name .");
let exec  = GenerateExecutor::new(query);

let mut row = HashMap::new();
row.insert("name".to_string(), "Alice".to_string());

let result = exec.evaluate_one(&row).unwrap();
assert_eq!(result.text, "name=Alice");

Fields

query: GenerateQuery

The parsed GENERATE query to execute.

Implementations

impl GenerateExecutor

pub fn new(query: GenerateQuery) -> Self

Create a new executor for the given GenerateQuery.

pub fn evaluate_one( &self, bindings: &Bindings, ) -> Result<GenerateResult, GenerateError>

Evaluate the GENERATE template against a single solution row.

Returns GenerateResult containing the concatenated text output and the count of distinct bindings used during evaluation.

Errors

Returns GenerateError::UnboundVariable if a Var reference in the template is not present in bindings.

pub fn evaluate_all( &self, rows: &[Bindings], ) -> Result<Vec<GenerateResult>, GenerateError>

Evaluate the GENERATE template over multiple solution rows, collecting one GenerateResult per row.

Errors

Propagates any error returned by evaluate_one.

pub fn generate_text( &self, rows: &[Bindings], separator: &str, ) -> Result<String, GenerateError>

Concatenate all generated texts (one per row) into a single String, with separator between each adjacent pair.

Errors

Propagates any error returned by evaluate_all.

pub fn eval_literal( &self, lit: &GenerateLiteral, bindings: &Bindings, ) -> Result<String, GenerateError>

Evaluate a single GenerateLiteral given bindings.

This is the public-facing variant without variable tracking; it is useful for unit-testing individual literal expressions.