Method analyze_query_statement

src/security/sql_injection_detector.rs:162–233

(
        &self,
        query: &sqlparser::ast::Query,
        analysis: &mut SqlAnalysisResult,
        depth: usize,
        original_query: &str
    )

    }

    fn analyze_query_statement(
        &self,
        query: &sqlparser::ast::Query,
        analysis: &mut SqlAnalysisResult,
        depth: usize,
        original_query: &str
    ) -> Result<(), PgSqliteError> {
        if let sqlparser::ast::SetExpr::Select(select) = &*query.body {
            // Analyze SELECT items
            for item in &select.projection {
                self.analyze_select_item(item, analysis, depth, original_query)?;
            }

            // Analyze FROM clause
            for table in &select.from {
                self.analyze_table_factor(&table.relation, analysis, depth, original_query)?;

                for join in &table.joins {
                    self.analyze_join(join, analysis, depth, original_query)?;
                }
            }

            // Analyze WHERE clause
            if let Some(ref where_clause) = select.selection {
                self.analyze_expression(where_clause, analysis, depth, original_query)?;
            }
        } else if let sqlparser::ast::SetExpr::SetOperation { op: _, left, right, .. } = &*query.body {
            analysis.union_count += 1;

            // Check for suspicious UNION patterns with sensitive data
            let query_str = original_query.to_uppercase();
            if (query_str.contains("UNION") && query_str.contains("PASSWORD")) ||
               (query_str.contains("UNION") && query_str.contains("ADMIN")) {
                events::sql_injection_attempt(None, None, original_query, "suspicious union with sensitive data");
                return Err(PgSqliteError::InvalidParameter(
                    "Suspicious UNION with sensitive data access".to_string()
                ));
            }

            // Recursively analyze the left and right parts
            let left_query = sqlparser::ast::Query {
                body: left.clone(),
                order_by: None,
                limit_clause: None,
                settings: None,
                fetch: None,
                locks: vec![],
                for_clause: None,
                with: None,
                format_clause: None,
                pipe_operators: vec![],
            };

            let right_query = sqlparser::ast::Query {
                body: right.clone(),
                order_by: None,
                limit_clause: None,
                settings: None,