Struct DeleteExecutor 

pub struct DeleteExecutor;

Executor for DELETE statements

Implementations

impl DeleteExecutor

pub fn execute( stmt: &DeleteStmt, database: &mut Database, ) -> Result<usize, ExecutorError>

Execute a DELETE statement

Arguments

• stmt - The DELETE statement AST node
• database - The database to delete from

Returns

Number of rows deleted or error

Examples

use vibesql_ast::{BinaryOperator, DeleteStmt, Expression, WhereClause};
use vibesql_catalog::{ColumnSchema, TableSchema};
use vibesql_executor::DeleteExecutor;
use vibesql_storage::Database;
use vibesql_types::{DataType, SqlValue};

let mut db = Database::new();

// Create table
let schema = TableSchema::new(
    "users".to_string(),
    vec![
        ColumnSchema::new("id".to_string(), DataType::Integer, false),
        ColumnSchema::new(
            "name".to_string(),
            DataType::Varchar { max_length: Some(50) },
            false,
        ),
    ],
);
db.create_table(schema).unwrap();

// Insert rows
db.insert_row(
    "users",
    vibesql_storage::Row::new(vec![
        SqlValue::Integer(1),
        SqlValue::Varchar(arcstr::ArcStr::from("Alice")),
    ]),
)
.unwrap();
db.insert_row(
    "users",
    vibesql_storage::Row::new(vec![
        SqlValue::Integer(2),
        SqlValue::Varchar(arcstr::ArcStr::from("Bob")),
    ]),
)
.unwrap();

// Delete specific row
let stmt = DeleteStmt {
    with_clause: None,
    only: false,
    table_name: "users".to_string(),
    quoted: false,
    where_clause: Some(WhereClause::Condition(Expression::BinaryOp {
        left: Box::new(Expression::ColumnRef(vibesql_ast::ColumnIdentifier::simple("id", false))),
        op: BinaryOperator::Equal,
        right: Box::new(Expression::Literal(SqlValue::Integer(1))),
    })),
    order_by: None,
    limit: None,
    offset: None,
};

let count = DeleteExecutor::execute(&stmt, &mut db).unwrap();
assert_eq!(count, 1);

pub fn execute_with_procedural_context( stmt: &DeleteStmt, database: &mut Database, procedural_context: &ExecutionContext, ) -> Result<usize, ExecutorError>

Execute a DELETE statement with procedural context Supports procedural variables in WHERE clause

pub fn execute_with_trigger_context( stmt: &DeleteStmt, database: &mut Database, trigger_context: &TriggerContext<'_>, ) -> Result<usize, ExecutorError>

Execute a DELETE statement with trigger context This allows DELETE statements within trigger bodies to reference OLD/NEW pseudo-variables