Merge 'remove Arc<RwLock<Statement>> from Insn::Program' from Pedro Muniz

`Program` should be an immutable set of instructions, and the
`Arc<RwLock<Statement>>` in `Insn::Program` violates this behaviour
breaking cached prepared statements.
I was exploring how we could properly isolate the translation code into
its own separate thing (if not in a crate at least logically), and I saw
we were creating statements and needing a pager for creating sub
programs.
Some of refactoring Claude helped, especially for `explain_step`

Closes #5501

Author: jussisaurio

core/translate/fkeys.rs

@@ -1,4 +1,3 @@
-use crate::sync::RwLock;
 use rustc_hash::FxHashSet as HashSet;
 use turso_parser::ast::{self, Expr, Literal, Name, QualifiedName, RefAct};
 
@@ -12,7 +11,7 @@ use crate::{
         insn::{CmpInsFlags, Insn},
         BranchOffset,
     },
-    Connection, LimboError, Result, Statement, Value,
+    Connection, LimboError, Result, Value,
 };
 use std::{num::NonZero, num::NonZeroUsize, sync::Arc};
 
@@ -1302,14 +1301,9 @@ fn emit_fk_action_subprogram(
         );
     }
 
-    let turso_stmt = Statement::new(
-        built_subprogram,
-        connection.pager.load().clone(),
-        QueryMode::Normal,
-    );
     program.emit_insn(Insn::Program {
         params,
-        program: Arc::new(RwLock::new(turso_stmt)),
+        program: built_subprogram.prepared().clone(),
     });
 
     Ok(())

core/translate/trigger_exec.rs

@@ -1,12 +1,11 @@
 use crate::schema::{BTreeTable, Trigger};
 use crate::sync::Arc;
-use crate::sync::RwLock;
 use crate::translate::emitter::Resolver;
 use crate::translate::expr::translate_expr;
 use crate::translate::{translate_inner, ProgramBuilder, ProgramBuilderOpts};
 use crate::util::normalize_ident;
 use crate::vdbe::insn::Insn;
-use crate::{bail_parse_error, QueryMode, Result, Statement};
+use crate::{bail_parse_error, QueryMode, Result};
 use rustc_hash::FxHashSet as HashSet;
 use std::num::NonZero;
 use turso_parser::ast::{self, Expr, TriggerEvent, TriggerTime};
@@ -649,14 +648,9 @@ fn execute_trigger_commands(
         );
     }
 
-    let turso_stmt = Statement::new(
-        built_subprogram,
-        connection.pager.load().clone(),
-        QueryMode::Normal,
-    );
     program.emit_insn(Insn::Program {
         params,
-        program: Arc::new(RwLock::new(turso_stmt)),
+        program: built_subprogram.prepared().clone(),
     });
     connection.end_trigger_compilation();
 

core/vdbe/builder.rs

@@ -1495,12 +1495,12 @@ impl ProgramBuilder {
         });
     }
 
-    pub fn build(
+    pub fn build_prepared_program(
         mut self,
-        connection: Arc<Connection>,
+        prepare_context: PrepareContext,
         change_cnt_on: bool,
         sql: &str,
-    ) -> crate::Result<Program> {
+    ) -> crate::Result<PreparedProgram> {
         self.resolve_labels()?;
 
         self.parameters.list.dedup();
@@ -1533,9 +1533,20 @@ impl ProgramBuilder {
             is_subprogram: self.is_subprogram,
             contains_trigger_subprograms,
             resolve_type: self.resolve_type,
-            prepare_context: PrepareContext::from_connection(&connection),
+            prepare_context,
             write_databases: self.write_databases,
         };
+        Ok(prepared)
+    }
+
+    pub fn build(
+        self,
+        connection: Arc<Connection>,
+        change_cnt_on: bool,
+        sql: &str,
+    ) -> crate::Result<Program> {
+        let prepare_context = PrepareContext::from_connection(&connection);
+        let prepared = self.build_prepared_program(prepare_context, change_cnt_on, sql)?;
         Ok(Program::from_prepared(Arc::new(prepared), connection))
     }
 }

core/vdbe/execute.rs

@@ -40,7 +40,6 @@ use crate::vector::{
     vector1bit, vector32, vector32_sparse, vector64, vector8, vector_concat, vector_distance_cos,
     vector_distance_dot, vector_distance_jaccard, vector_distance_l2, vector_extract, vector_slice,
 };
-use crate::CdcVersion;
 use crate::{
     error::{
         LimboError, SQLITE_CONSTRAINT, SQLITE_CONSTRAINT_CHECK, SQLITE_CONSTRAINT_NOTNULL,
@@ -59,8 +58,9 @@ use crate::{
 };
 use crate::{
     get_cursor, CaptureDataChangesInfo, CheckpointMode, Completion, Connection, DatabaseStorage,
-    IOExt, MvCursor,
+    IOExt, MvCursor, QueryMode,
 };
+use crate::{CdcVersion, Statement};
 use either::Either;
 use smallvec::SmallVec;
 use std::any::Any;
@@ -2810,6 +2810,7 @@ pub enum OpProgramState {
     /// Step state tracks whether we're executing a trigger subprogram (vs FK action subprogram)
     Step {
         is_trigger: bool,
+        statement: Box<Statement>,
     },
 }
 
@@ -2819,7 +2820,7 @@ pub fn op_program(
     program: &Program,
     state: &mut ProgramState,
     insn: &Insn,
-    _pager: &Arc<Pager>,
+    pager: &Arc<Pager>,
 ) -> Result<InsnFunctionStepResult> {
     load_insn!(
         Program {
@@ -2831,7 +2832,11 @@ pub fn op_program(
     loop {
         match &mut state.op_program_state {
             OpProgramState::Start => {
-                let mut statement = subprogram.write();
+                let mut statement = Statement::new(
+                    Program::from_prepared(subprogram.clone(), program.connection.clone()),
+                    pager.clone(),
+                    QueryMode::Normal,
+                );
                 statement.reset();
 
                 // Check if this is a trigger subprogram - if so, track execution
@@ -2867,12 +2872,17 @@ pub fn op_program(
                     }
                 }
 
-                state.op_program_state = OpProgramState::Step { is_trigger };
+                state.op_program_state = OpProgramState::Step {
+                    is_trigger,
+                    statement: Box::new(statement),
+                };
             }
-            OpProgramState::Step { is_trigger } => {
+            OpProgramState::Step {
+                is_trigger,
+                statement,
+            } => {
                 let is_trigger = *is_trigger;
                 loop {
-                    let mut statement = subprogram.write();
                     let res = statement.step();
                     match res {
                         Ok(step_result) => match step_result {

core/vdbe/explain.rs

@@ -2,7 +2,7 @@ use turso_parser::ast::SortOrder;
 
 use crate::vdbe::{builder::CursorType, insn::RegisterOrLiteral};
 
-use super::{Insn, InsnReference, Program, Value};
+use super::{Insn, InsnReference, PreparedProgram, Value};
 use crate::function::{Func, ScalarFunc};
 
 pub const EXPLAIN_COLUMNS: [&str; 8] = ["addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment"];
@@ -13,7 +13,7 @@ pub const EXPLAIN_QUERY_PLAN_COLUMNS: [&str; 4] = ["id", "parent", "notused", "d
 pub const EXPLAIN_QUERY_PLAN_COLUMNS_TYPE: [&str; 4] = ["INTEGER", "INTEGER", "INTEGER", "TEXT"];
 
 pub fn insn_to_row(
-    program: &Program,
+    program: &PreparedProgram,
     insn: &Insn,
 ) -> (&'static str, i64, i64, i64, Value, i64, String) {
     let get_table_or_index_name = |cursor_id: usize| {
@@ -2084,7 +2084,7 @@ pub fn insn_to_row(
 }
 
 pub fn insn_to_row_with_comment(
-    program: &Program,
+    program: &PreparedProgram,
     insn: &Insn,
     manual_comment: Option<&str>,
 ) -> (&'static str, i64, i64, i64, Value, i64, String) {
@@ -2101,7 +2101,7 @@ pub fn insn_to_row_with_comment(
 }
 
 pub fn insn_to_str(
-    program: &Program,
+    program: &PreparedProgram,
     addr: InsnReference,
     insn: &Insn,
     indent: String,

core/vdbe/insn.rs

@@ -11,14 +11,13 @@ pub fn to_u16(v: usize) -> u16 {
 }
 
 use super::{execute, AggFunc, BranchOffset, CursorID, FuncCtx, InsnFunction, PageIdx};
-use crate::sync::RwLock;
 use crate::{
     schema::{BTreeTable, CheckConstraint, Column, Index},
     storage::{pager::CreateBTreeFlags, wal::CheckpointMode},
     translate::{collate::CollationSeq, emitter::TransactionMode},
     types::KeyInfo,
     vdbe::affinity::Affinity,
-    Statement, Value,
+    PreparedProgram, Value,
 };
 use strum::EnumCount;
 use strum_macros::{EnumDiscriminants, FromRepr, VariantArray};
@@ -615,7 +614,7 @@ pub enum Insn {
     /// is used by subprograms to access content in registers of the calling bytecode program."
     Program {
         params: Vec<Value>,
-        program: Arc<RwLock<Statement>>,
+        program: Arc<PreparedProgram>,
     },
 
     /// Write an integer value into a register.