Method process

src/query/lazy_processor.rs:144–356

Process the query lazily - only do the work when needed

(&mut self, conn: &Connection, _schema_cache: &SchemaCache)

    
    /// Process the query lazily - only do the work when needed
    pub fn process(&mut self, conn: &Connection, _schema_cache: &SchemaCache) -> Result<&str, rusqlite::Error> {
        // Re-enable translations now that wire protocol cache is disabled
        // tracing::info!("TESTING: All query translations disabled - returning original query: {}", self.original_query);
        // return Ok(self.original_query);
        
        // If already processed, return the result
        if let Some(ref translated) = self.translated_query {
            return Ok(translated.as_ref());
        }
        
        // Fast path - if no translation is needed, return original query directly
        if !self.needs_cast_translation && !self.needs_regex_translation &&
           !self.needs_schema_translation && !self.needs_numeric_cast_translation &&
           !self.needs_array_translation && !self.needs_delete_using_translation &&
           !self.needs_batch_update_translation && !self.needs_datetime_translation &&
           !self.needs_pg_table_is_visible_translation && !self.needs_session_identifier_translation {
            // Check if this is an INSERT that might need decimal rewrite
            if matches!(QueryTypeDetector::detect_query_type(self.original_query), QueryType::Insert) {
                if let Some(table_name) = extract_insert_table_name(self.original_query)
                    && !_schema_cache.has_decimal_columns(&table_name) {
                        return Ok(self.original_query);
                    }
            } else if !matches!(QueryTypeDetector::detect_query_type(self.original_query), QueryType::Select) {
                // Not a SELECT or INSERT that needs decimal handling
                return Ok(self.original_query);
            }
        }
        
        let mut current_query = Cow::Borrowed(self.original_query);
        
        // Step 1: pg_table_is_visible removal if needed (must come before array translation)
        if self.needs_pg_table_is_visible_translation {
            tracing::debug!("Before pg_table_is_visible translation: {}", current_query);
            let translated = crate::translator::PgTableIsVisibleTranslator::translate(&current_query);
            tracing::debug!("After pg_table_is_visible translation: {}", translated);
            current_query = Cow::Owned(translated);
        }

        // Step 1.5: Session identifier translation if needed (add parentheses to current_user, session_user)
        if self.needs_session_identifier_translation {
            tracing::debug!("Before session identifier translation: {}", current_query);
            let translated = crate::translator::SessionIdentifierTranslator::translate_query(&current_query);
            tracing::debug!("After session identifier translation: {}", translated);
            current_query = Cow::Owned(translated);
        }

        // Step 2: Schema prefix removal if needed
        if self.needs_schema_translation {
            tracing::debug!("Before schema translation: {}", current_query);
            let translated = crate::translator::SchemaPrefixTranslator::translate_query(&current_query);
            tracing::debug!("After schema translation: {}", translated);
            current_query = Cow::Owned(translated);
        }
        
        // Step 3: Numeric cast translation MUST come before general cast translation
        // to ensure CAST(x AS NUMERIC(p,s)) is handled properly
        if self.needs_numeric_cast_translation {
            tracing::debug!("Before numeric cast translation: {}", current_query);