Method transform_text_search_node

graphlite/src/plan/optimizer.rs:533–622

Recursively transform nodes to detect text search patterns

(&self, node: LogicalNode)

    /// Recursively transform nodes to detect text search patterns
    fn transform_text_search_node(&self, node: LogicalNode) -> Result<LogicalNode, PlanningError> {
        match node {
            // Transform Filter nodes that contain text search predicates
            LogicalNode::Filter { condition, input } => {
                // First, recursively transform the input
                let transformed_input = Box::new(self.transform_text_search_node(*input)?);

                // Text search is not supported in GraphLite, keep as Filter
                Ok(LogicalNode::Filter {
                    condition,
                    input: transformed_input,
                })
            }

            // Recursively transform other node types
            LogicalNode::Project { expressions, input } => Ok(LogicalNode::Project {
                expressions,
                input: Box::new(self.transform_text_search_node(*input)?),
            }),

            LogicalNode::Join {
                left,
                right,
                join_type,
                condition,
            } => Ok(LogicalNode::Join {
                left: Box::new(self.transform_text_search_node(*left)?),
                right: Box::new(self.transform_text_search_node(*right)?),
                join_type,
                condition,
            }),

            LogicalNode::Union { inputs, all } => {
                let transformed_inputs: Result<Vec<_>, _> = inputs
                    .into_iter()
                    .map(|input| self.transform_text_search_node(input))
                    .collect();
                Ok(LogicalNode::Union {
                    inputs: transformed_inputs?,
                    all,
                })
            }

            LogicalNode::Aggregate {
                group_by,
                aggregates,
                input,
            } => Ok(LogicalNode::Aggregate {
                group_by,
                aggregates,
                input: Box::new(self.transform_text_search_node(*input)?),
            }),

            LogicalNode::Sort { expressions, input } => Ok(LogicalNode::Sort {
                expressions,
                input: Box::new(self.transform_text_search_node(*input)?),
            }),