Method execute_query

src/query/executor.rs:180–256

(
        framed: &mut Framed<T, crate::protocol::PostgresCodec>,
        db: &Arc<DbHandler>,
        session: &Arc<SessionState>,
        query: &str,
        query_router: Option<&Arc<QueryRouter>>

        }
    }
    pub async fn execute_query<T>(
        framed: &mut Framed<T, crate::protocol::PostgresCodec>,
        db: &Arc<DbHandler>,
        session: &Arc<SessionState>,
        query: &str,
        query_router: Option<&Arc<QueryRouter>>,
    ) -> Result<(), PgSqliteError>
    where
        T: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin + Send,
    {
        println!("EXECUTOR: execute_query called with: '{}'", query);
        // Executing query
        
        // Strip SQL comments first to avoid parsing issues
        let cleaned_query = crate::query::strip_sql_comments(query);
        let query_to_execute = cleaned_query.trim();
        
        // Check if query is empty after comment stripping
        if query_to_execute.is_empty() {
            return Err(PgSqliteError::Protocol(error_message!("Empty query").into_owned()));
        }
        
        // Handle PostgreSQL DEALLOCATE commands (used for prepared statement cleanup)
        let query_upper = query_to_execute.to_uppercase();
        if query_upper.starts_with("DEALLOCATE") {
            debug!("DEALLOCATE command - treating as successful no-op (SQLite manages prepared statements automatically)");
            // Send CommandComplete for successful DEALLOCATE
            let msg = BackendMessage::CommandComplete { tag: error_message!("DEALLOCATE").into_owned() };
            framed.send(msg).await.map_err(PgSqliteError::Io)?;
            return Ok(());
        }
        
        // debug!("Executing query: {}", query_to_execute);
        
        // Check for Python-style parameters and provide helpful error
        use crate::query::parameter_parser::ParameterParser;
        let python_params = ParameterParser::find_python_parameters(query_to_execute);
        if !python_params.is_empty() {
            let error_msg = format!(
                "Python-style parameters detected: {python_params:?}. pgsqlite requires parameter values to be substituted before execution. This usually means psycopg2 client-side substitution failed. Please ensure parameters are properly bound when executing the query."
            );
            debug!("⚠️  {}", error_msg);
            debug!("Query: {}", query_to_execute);
            return Err(PgSqliteError::Protocol(error_msg));
        }
        
        // Check if query contains multiple statements
        let trimmed = query_to_execute.trim();
        if trimmed.contains(';') {
            // Split by semicolon and execute each statement
            let statements: Vec<&str> = trimmed.split(';')
                .map(|s| s.trim())
                .filter(|s| !s.is_empty())
                .collect();
            
            // Handle empty query case (just semicolon) - SQLAlchemy uses ";" for ping
            if statements.is_empty() {
                debug!("Empty query (just semicolon) - treating as successful no-op");