Struct CreateTableExecutor 

pub struct CreateTableExecutor;

Executor for CREATE TABLE statements

Implementations

impl CreateTableExecutor

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

Execute a CREATE TABLE statement

Arguments

• stmt - The CREATE TABLE statement AST node
• database - The database to create the table in

Returns

Success message or error

Examples

use vibesql_ast::{ColumnDef, CreateTableStmt};
use vibesql_executor::CreateTableExecutor;
use vibesql_storage::Database;
use vibesql_types::DataType;

let mut db = Database::new();
let stmt = CreateTableStmt { temporary: false,
    if_not_exists: false,
    table_name: "users".to_string(),
    columns: vec![
        ColumnDef {
            name: "id".to_string(),
            data_type: DataType::Integer,
            nullable: false,
            constraints: vec![],
            default_value: None,
            comment: None,
            generated_expr: None, is_exact_integer_type: false,
        },
        ColumnDef {
            name: "name".to_string(),
            data_type: DataType::Varchar { max_length: Some(255) },
            nullable: true,
            constraints: vec![],
            default_value: None,
            comment: None,
            generated_expr: None, is_exact_integer_type: false,
        },
    ],
    table_constraints: vec![],
    table_options: vec![],
    quoted: false,
    name_source: None,
    as_query: None, without_rowid: false,
};

let result = CreateTableExecutor::execute(&stmt, &mut db);
assert!(result.is_ok());

pub fn execute_with_source( stmt: &CreateTableStmt, database: &mut Database, sql_source: Option<&str>, ) -> Result<String, ExecutorError>

Execute a CREATE TABLE statement (user-facing path), recording the verbatim original source text.

SQLite stores the byte-for-byte original CREATE TABLE statement in sqlite_master.sql (whitespace and formatting preserved). When sql_source is Some, it is stamped onto the catalog TableSchema so that sqlite_master/sqlite_schema returns it verbatim instead of a reconstruction. The trailing semicolon (if any) is stripped by TableSchema::set_sql_source to match SQLite. Pass None when the source text is unavailable (e.g. AST built programmatically); callers then fall back to reconstructing the SQL. See issue #5619.

This is the UNTRUSTED path — it keeps the #5614 reserved-name and #5553 duplicate-column guards. For replaying a persisted dump use [execute_for_load_with_source].

pub fn execute_for_load( stmt: &CreateTableStmt, database: &mut Database, ) -> Result<String, ExecutorError>

Execute a CREATE TABLE statement on a TRUSTED (engine-internal) path.

This is used when replaying the engine’s own persisted schema (e.g. load_sql_dump / consensus state-machine replay), not for user-issued DDL. A persisted dump is engine-internal data that was already validated when first created, so it must always round-trip — it must NOT be re-rejected by the user-facing conformance guards.

Specifically this skips:

• the reserved sqlite_-prefix guard, so a table that legitimately reached the catalog (e.g. a pre-#5614 DB where ALTER TABLE RENAME TO sqlite_x was still accepted) reloads cleanly instead of bricking the database (issue #5614);
• the duplicate-column guard, for the same backward-compat reason — a schema that was once persisted must remain loadable.

All other validation (namespace collisions, etc.) still applies, matching the prior behavior of the load path for #5613.

pub fn execute_for_load_with_source( stmt: &CreateTableStmt, database: &mut Database, sql_source: Option<&str>, ) -> Result<String, ExecutorError>

Trusted load path (see [execute_for_load]) that ALSO records the verbatim original CREATE TABLE source text for sqlite_master.sql.

This is the entry point used when reloading a persisted .sql dump: it must bypass the user-facing guards (#5614/#5553) so a previously persisted schema always round-trips, while still preserving the byte-for- byte original source so sqlite_master.sql keeps the user’s formatting across a save/reload cycle (issue #5619).