pub use super::script_split::{split, validate_delimiter, Piece, Statements};
use super::prepare::{self, Gated};
use super::{change, read, Policy, WriteState};
use crate::error::Result;
use crate::sql::classify::Classification;
use mysql_async::Conn;
use serde_json::{json, Value};
#[must_use]
pub const fn escapes_block(classification: Classification) -> bool {
matches!(
classification,
Classification::Definition | Classification::Administration
)
}
#[must_use]
pub fn escape_notice(
piece: &Piece,
classification: Classification,
) -> crate::output::envelope::Gap {
crate::output::envelope::Gap::new(
format!("statement_{}", piece.index),
"escapes_atomic_block",
format!(
"the statement on line {} is a {} and confirms itself, so the block cannot undo it",
piece.line,
classification.as_str()
),
)
}
pub struct Run<'a> {
pub conn: &'a mut Conn,
pub policy: &'a Policy,
pub write_state: &'a mut WriteState,
pub server_read_only: bool,
pub conversion: &'a crate::types::Conversion,
pub stop_on_failure: bool,
}
pub async fn confirm_changes(conn: &mut Conn) -> Result<()> {
prepare::exec_drop(conn, CONFIRM_BLOCK, mysql_async::Params::Empty).await
}
pub const BEGIN_BLOCK: &str = "START TRANSACTION";
pub const CONFIRM_BLOCK: &str = "COMMIT";
pub const UNDO_BLOCK: &str = "ROLLBACK";
pub async fn one_of_many(gated: &Gated, run: &mut Run<'_>) -> Result<Value> {
if gated.classification().is_read() {
let result = read::collect(run.conn, gated, run.policy.max_rows, run.conversion).await?;
return Ok(json!({"read": true, "row_count": result.rows.len()}));
}
let outcome = change::apply(
gated,
run.conn,
run.policy,
run.write_state,
run.server_read_only,
)
.await?;
Ok(change::describe(gated, &outcome))
}
pub const FILE_COLUMNS: [&str; 3] = ["statement", "line", "outcome"];
async fn record_of(piece: Piece, run: &mut Run<'_>) -> Result<crate::output::Row> {
let (index, line) = (piece.index, piece.line);
let stop = run.stop_on_failure;
match attempt(piece, run).await {
Ok(record) => Ok(record),
Err(failure) if stop => Err(failure),
Err(failure) => Ok(refused(index, line, &failure)),
}
}
fn refused(index: usize, line: usize, failure: &crate::error::Failure) -> crate::output::Row {
let mut record = crate::output::Row::new();
record.insert("statement".to_owned(), json!(index));
record.insert("line".to_owned(), json!(line));
record.insert(
"outcome".to_owned(),
json!({
"failed": true,
"code": failure.code(),
"message": failure.message(),
"exit": failure.exit_number().code(),
}),
);
record
}
async fn attempt(piece: Piece, run: &mut Run<'_>) -> Result<crate::output::Row> {
let where_it_is = format!("statement {}, line {}", piece.index, piece.line);
let gated = prepare::gate(&piece.sql, &[], run.policy)
.map_err(|failure| failure.with_cause(where_it_is.clone()))?;
drop(piece.sql);
let outcome = one_of_many(&gated, run)
.await
.map_err(|failure| failure.with_cause(where_it_is))?;
let mut record = crate::output::Row::new();
record.insert("statement".to_owned(), json!(piece.index));
record.insert("line".to_owned(), json!(piece.line));
record.insert("outcome".to_owned(), outcome);
Ok(record)
}
pub async fn run_file<S: IntoIterator<Item = Piece>>(
statements: S,
run: &mut Run<'_>,
) -> Result<Value> {
let mut answers = Vec::new();
for piece in statements {
let record = record_of(piece, run).await?;
answers.push(Value::Object(record.into_iter().collect()));
}
if !run.policy.dry_run {
confirm_changes(run.conn).await?;
}
Ok(json!({"statement_count": answers.len(), "rows": answers}))
}
pub async fn stream_file<W: std::io::Write, S: IntoIterator<Item = Piece>>(
statements: S,
run: &mut Run<'_>,
sink: crate::output::stream::Sink<'_, W>,
pipeline: &crate::output::Pipeline,
token: &tokio_util::sync::CancellationToken,
) -> Result<u64> {
let crate::output::stream::Sink {
writer,
formatter,
tail,
} = sink;
let columns: Vec<String> = FILE_COLUMNS.iter().map(|name| (*name).to_owned()).collect();
let mut formatter = formatter;
let mut stage = pipeline.flow_framed(&mut *formatter, tail, &columns, 0, &[])?;
let mut flow = crate::output::stream::Stream::open(writer, formatter, tail, &columns)?;
let mut still_emitting = true;
for piece in statements {
if token.is_cancelled() {
return Err(crate::error::Failure::interrupted(
"interrupted.between_statements",
"the invocation was stopped between two statements of the file",
));
}
let record = record_of(piece, run).await?;
if !still_emitting {
continue;
}
match stage.offer(record) {
crate::output::ops::Step::Emit(shaped) => flow.write(&shaped)?,
crate::output::ops::Step::Skip => {}
crate::output::ops::Step::Stop => still_emitting = false,
}
}
if !run.policy.dry_run {
confirm_changes(run.conn).await?;
}
if stage.is_whole() {
return flow.finish(tail, &[], stage.applied().as_ref());
}
Ok(flow.emitted())
}
pub fn gate_block(
statements: &[String],
policy: &Policy,
) -> Result<(Vec<Gated>, Vec<crate::output::envelope::Gap>)> {
let mut gaps = Vec::new();
let mut gated = Vec::new();
for (position, text) in statements.iter().enumerate() {
let one = prepare::gate(text, &[], policy)?;
if escapes_block(one.classification()) {
let piece = Piece {
index: position + 1,
line: position + 1,
sql: text.clone(),
};
gaps.push(escape_notice(&piece, one.classification()));
}
gated.push(one);
}
Ok((gated, gaps))
}
pub async fn run_block(gated: &[Gated], run: &mut Run<'_>) -> Result<Value> {
prepare::exec_drop(run.conn, BEGIN_BLOCK, mysql_async::Params::Empty).await?;
let mut answers = Vec::new();
for one in gated {
match one_of_many(one, run).await {
Ok(answer) => answers.push(answer),
Err(failure) => {
let _ = prepare::exec_drop(run.conn, UNDO_BLOCK, mysql_async::Params::Empty).await;
return Err(failure);
}
}
}
prepare::exec_drop(run.conn, CONFIRM_BLOCK, mysql_async::Params::Empty).await?;
Ok(json!({"rows": answers, "confirmed": true, "statement_count": gated.len()}))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_statement_that_confirms_itself_always_escapes_the_block() {
assert!(escapes_block(Classification::Definition));
assert!(escapes_block(Classification::Administration));
assert!(!escapes_block(Classification::Change));
assert!(!escapes_block(Classification::Read));
let piece = Piece {
index: 3,
line: 12,
sql: "CREATE TABLE t (a INT)".to_owned(),
};
let notice = escape_notice(&piece, Classification::Definition);
assert_eq!(notice.object, "statement_3");
assert_eq!(notice.cause, "escapes_atomic_block");
assert!(notice.detail.contains("12") && notice.detail.contains("definition"));
}
}