Struct ProgramBuilder 

pub struct ProgramBuilder { /* private fields */ }

A VDBE bytecode program under construction.

Provides methods to emit instructions, create/resolve labels for forward jumps, and allocate registers. Once construction is complete, call finish to validate and extract the final instruction sequence.

Implementations

impl ProgramBuilder

pub fn new() -> Self

Create a new empty program builder.

pub fn emit(&mut self, op: VdbeOp) -> usize

Emit a single instruction and return its address (index in ops).

pub fn emit_op( &mut self, opcode: Opcode, p1: i32, p2: i32, p3: i32, p4: P4, p5: u16, ) -> usize

Emit a simple instruction from parts.

pub fn current_addr(&self) -> usize

The current address (index of the next instruction to be emitted).

pub fn op_at(&self, addr: usize) -> Option<&VdbeOp>

Get a reference to the instruction at addr.

pub fn op_at_mut(&mut self, addr: usize) -> Option<&mut VdbeOp>

Get a mutable reference to the instruction at addr.

pub fn emit_label(&mut self) -> Label

Create a new label for forward-reference jumps.

pub fn emit_jump_to_label( &mut self, opcode: Opcode, p1: i32, p3: i32, label: Label, p4: P4, p5: u16, ) -> usize

Emit a jump instruction whose p2 target is a label (forward reference).

The label’s address will be patched into p2 when resolve_label is called.

pub fn resolve_label(&mut self, label: Label)

Resolve a label to the current address and patch all forward refs.

pub fn resolve_label_to(&mut self, label: Label, address: i32)

Resolve a label to an explicit address (used for some control patterns).

pub fn alloc_reg(&mut self) -> i32

Allocate a single persistent register.

pub fn alloc_regs(&mut self, n: i32) -> i32

Allocate a contiguous block of persistent registers.

pub fn alloc_temp(&mut self) -> i32

Allocate a temporary register (reusable).

pub fn free_temp(&mut self, reg: i32)

Return a temporary register to the pool.

pub fn register_count(&self) -> i32

Total registers allocated (high water mark).

pub fn apply_fuse_literal_result_row(&mut self) -> usize

Fuse Integer(lit, reg) + ResultRow(reg, 1) pairs into FusedLiteralResultRow(lit, reg) + Noop.

Rewrites in-place so program counters, jump targets, and the label tables remain valid without rewiring. The ResultRow is replaced by a Noop rather than removed so no following instruction shifts.

Conservative preconditions per fusion site:

• The Integer’s target register equals the ResultRow’s start register.
• The ResultRow emits exactly one column (p2 == 1).
• The ResultRow is NOT a resolved jump target from any prior jump in this program (a mid-pair jump would otherwise skip the Integer write and run ResultRow against an unrelated register value).
• Neither instruction carries a non-None P4 payload (Integer/ResultRow don’t use P4 in their canonical form).
• Both instructions carry P5 == 0 and P3 == 0.

Returns the number of fusions performed.

pub fn finish(self) -> Result<VdbeProgram>

Validate all labels are resolved and return the finished program.

Trait Implementations

impl Debug for ProgramBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ProgramBuilder

fn default() -> Self

Returns the “default value” for a type.