Struct Reducer 

pub struct Reducer {
    rules: ReductionRules,
    checker: Checker,
}

Fields

rules: ReductionRules

checker: Checker

Implementations

impl Reducer

pub fn new(checker: Checker) -> Self

pub async fn reduce(&mut self, sql: &str) -> Result<String>

Perform reduction on a SQL input containing multiple statements, where only the last statement is considered the failing one.

The reducer:

1. Executes all preceding statements using the checker client.
2. Verifies that the last statement indeed fails (self-check).
3. Applies transformation passes to simplify the failing query while preserving the failure behavior.
4. Returns the reduced failing SQL query as a string.

Arguments

• sql: A SQL string with multiple statements (e.g., setup + failing query).

Returns

• A simplified version of the last statement that still fails in the same way.
• The preceding statements are also returned as a string.

Errors

• Returns an error if SQL parsing fails or if no statements are found.
• Panics if the checker fails to validate failure preservation on the original failing query.

async fn reduce_path_based(&mut self, sql: &str) -> String

Path-based reduction approach using systematic AST traversal.

This method:

1. Enumerates all reduction paths in the AST
2. Generates reduction candidates based on rules
3. Applies candidates one-by-one, validating after each successful application
4. Uses a seen-query cache to avoid redundant checks

async fn try_batch_with_binary_search( &mut self, ast_node: &AstNode, candidates: &[ReductionCandidate], group_indices: &[usize], original_sql: &str, sql_len: usize, seen_queries: &mut HashSet<String>, batch_type: &str, base_path: &AstPath, ) -> Option<(AstNode, String, usize)>

Try to apply a batch of operations using binary search to find the maximum working batch size.

Binary search strategy:

• Start with the full batch size
• If it works, return success immediately
• If it fails, binary search for the largest working subset

Returns: (AST, SQL, applied_count) if any batch succeeds, None otherwise