Struct RunSQL 

pub struct RunSQL {
    pub sql: String,
    pub reverse_sql: Option<String>,
    pub state_operations: Vec<StateOperation>,
}

Available on native and crate feature database only.

Execute raw SQL

This operation allows you to execute arbitrary SQL statements during migration. It’s useful for data migrations, custom schema modifications, or database-specific operations.

Example

use reinhardt_db::migrations::operations::special::RunSQL;

// Simple SQL execution
let sql = RunSQL::new("CREATE INDEX idx_email ON users(email)");

// With reverse SQL for rollback
let sql_reversible = RunSQL::new("CREATE INDEX idx_email ON users(email)")
    .with_reverse_sql("DROP INDEX idx_email");

// Multiple statements
let multi_sql = RunSQL::new_multi(vec![
    "INSERT INTO roles (name) VALUES ('admin')".to_string(),
    "INSERT INTO roles (name) VALUES ('user')".to_string(),
]);

Fields

sql: String

The sql.

reverse_sql: Option<String>

The reverse sql.

state_operations: Vec<StateOperation>

The state operations.

Implementations

impl RunSQL

pub fn new(sql: impl Into<String>) -> RunSQL

Create a new RunSQL operation

Example

use reinhardt_db::migrations::operations::special::RunSQL;

let sql = RunSQL::new("INSERT INTO config (key, value) VALUES ('version', '1.0')");
assert!(sql.reverse_sql.is_none());

pub fn new_multi(statements: Vec<String>) -> RunSQL

Create a RunSQL operation with multiple statements

Example

use reinhardt_db::migrations::operations::special::RunSQL;

let sql = RunSQL::new_multi(vec![
    "UPDATE users SET active = true WHERE id = 1".to_string(),
    "UPDATE users SET active = false WHERE id = 2".to_string(),
]);

assert!(sql.sql.contains("UPDATE users SET active = true"));
assert!(sql.sql.contains("UPDATE users SET active = false"));

pub fn with_reverse_sql(self, reverse_sql: impl Into<String>) -> RunSQL

Set reverse SQL for rollback

Example

use reinhardt_db::migrations::operations::special::RunSQL;

let sql = RunSQL::new("CREATE INDEX idx_email ON users(email)")
    .with_reverse_sql("DROP INDEX idx_email");

assert!(sql.reverse_sql.is_some());
assert_eq!(sql.reverse_sql.unwrap(), "DROP INDEX idx_email");

pub fn with_state_operations(self, operations: Vec<StateOperation>) -> RunSQL

Add state operations to be applied along with the SQL

This allows you to keep the project state in sync when running custom SQL.

pub fn state_forwards(&self, app_label: &str, state: &mut ProjectState)

Apply to project state (forward)

RunSQL doesn’t modify state by default unless state_operations are specified

pub fn database_forwards( &self, _schema_editor: &dyn BaseDatabaseSchemaEditor, ) -> Vec<String>

Generate SQL

Example

use reinhardt_db::migrations::operations::special::RunSQL;
use reinhardt_db::backends::schema::factory::{SchemaEditorFactory, DatabaseType};

let sql = RunSQL::new("SELECT 1");
let factory = SchemaEditorFactory::new();
let editor = factory.create_for_database(DatabaseType::PostgreSQL);

let statements = sql.database_forwards(editor.as_ref());
assert_eq!(statements.len(), 1);
assert_eq!(statements[0], "SELECT 1");

pub fn get_reverse_sql(&self) -> Option<&str>

Get reverse SQL for rollback

Example

use reinhardt_db::migrations::operations::special::RunSQL;

let sql = RunSQL::new("CREATE TABLE temp (id INT)")
    .with_reverse_sql("DROP TABLE temp");

assert_eq!(sql.get_reverse_sql(), Some("DROP TABLE temp"));

let irreversible = RunSQL::new("DROP TABLE important_data");
assert_eq!(irreversible.get_reverse_sql(), None);

Trait Implementations

impl Clone for RunSQL

fn clone(&self) -> RunSQL

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RunSQL

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RunSQL

fn deserialize<__D>( __deserializer: __D, ) -> Result<RunSQL, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl MigrationOperation for RunSQL

fn migration_name_fragment(&self) -> Option<String>

Generate a fragment for the migration name

fn describe(&self) -> String

Human-readable description of this operation

fn normalize(&self) -> Self

where Self: Sized + Clone,

Normalize operation for comparison

fn semantically_equal(&self, other: &Self) -> bool

where Self: Sized + Clone + PartialEq,

Check if two operations are semantically equal

impl Serialize for RunSQL

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.