use super::query::{envelope, read_standard_input, statement_text, Context};
use crate::cli::query::{CallArgs, FileArgs, StatementArgs, TxArgs};
use crate::error::{Failure, Result};
use crate::exec::{change, plan, prepare, routine, script};
use crate::output::Envelope;
use mysql_async::Conn;
use serde_json::json;
pub(super) async fn measure(
args: &StatementArgs,
conn: &mut Conn,
context: &mut Context,
server_read_only: bool,
) -> Result<Envelope> {
let text = statement_text(args, context.refuses_to_ask, context.policy.max_input_bytes)?;
let gated = prepare::gate(&text, &args.params, &context.policy)?;
plan::refuse_unplannable(&gated)?;
context.policy.admit_change("query analyze")?;
context.policy.admit_simulation("query analyze")?;
context.write_state.admit(server_read_only)?;
let (predicted, gap) = change::admit_scale(conn, &gated, context.policy.max_affected).await?;
let request = plan::measure(&gated)?;
let rows = prepare::exec_rows(conn, &request, gated.params(), &context.conversion).await?;
Ok(envelope(
"query analyze",
json!({"rows": rows, "measured": true, "predicted_rows": predicted}),
gap.into_iter().collect(),
))
}
pub(crate) fn script_to_run(
args: &FileArgs,
policy: &crate::exec::Policy,
) -> Result<(String, String)> {
let path = file_to_run(args)?;
let delimiter = args
.delimiter
.clone()
.unwrap_or_else(|| policy.delimiter.clone());
script::validate_delimiter(&delimiter)?;
let text = super::input::file_within(&path, policy.max_input_bytes)?;
Ok((text, delimiter))
}
pub(super) async fn file(
args: &FileArgs,
conn: &mut Conn,
context: &mut Context,
server_read_only: bool,
) -> Result<Envelope> {
let (text, delimiter) = script_to_run(args, &context.policy)?;
let statements = script::split(&text, &delimiter)?;
let mut run = script::Run {
conn,
policy: &context.policy,
write_state: &mut context.write_state,
server_read_only,
conversion: &context.conversion,
stop_on_failure: stops_at_the_first_failure(args),
};
let data = script::run_file(statements, &mut run).await?;
Ok(Envelope::new("query file", data))
}
#[must_use]
pub fn stops_at_the_first_failure(args: &FileArgs) -> bool {
args.on_error.is_none_or(crate::cli::data::OnError::stops)
}
pub(super) async fn block(
args: &TxArgs,
conn: &mut Conn,
context: &mut Context,
server_read_only: bool,
) -> Result<Envelope> {
let statements =
block_statements(args, context.refuses_to_ask, context.policy.max_input_bytes)?;
context.policy.admit_change("query tx")?;
context.write_state.admit(server_read_only)?;
let (gated, gaps) = script::gate_block(&statements, &context.policy)?;
let mut run = script::Run {
conn,
policy: &context.policy,
write_state: &mut context.write_state,
server_read_only,
conversion: &context.conversion,
stop_on_failure: true,
};
let data = script::run_block(&gated, &mut run).await?;
Ok(envelope("query tx", data, gaps))
}
fn block_statements(args: &TxArgs, refuses_to_ask: bool, ceiling: usize) -> Result<Vec<String>> {
if !args.statements.is_empty() {
return Ok(args.statements.clone());
}
if let Some(path) = &args.file {
let text = super::input::file_within(path, ceiling)?;
return Ok(lines_of(&text));
}
if !args.stdin {
return Err(
Failure::usage("usage.no_statement", "the block carries no statement")
.with_hint("give each statement with --statement, with --file, or pass --stdin"),
);
}
Ok(lines_of(&read_standard_input(refuses_to_ask, ceiling)?))
}
fn lines_of(text: &str) -> Vec<String> {
text.lines()
.map(str::trim)
.filter(|line| !line.is_empty())
.map(ToOwned::to_owned)
.collect()
}
pub(super) async fn call(
args: &CallArgs,
conn: &mut Conn,
context: &mut Context,
server_read_only: bool,
) -> Result<Envelope> {
let routine_name = routine_to_call(args)?;
let split = crate::introspect::names::split(&routine_name);
let data = routine::serve(
routine::Call {
routine: &split.name,
database: split.database.as_deref().or(context.database.as_deref()),
values: &args.params,
outputs: &args.outputs,
},
conn,
&context.policy,
&mut context.write_state,
server_read_only,
&context.conversion,
)
.await?;
Ok(Envelope::new("query call", data))
}
fn file_to_run(args: &FileArgs) -> Result<std::path::PathBuf> {
args.path.clone().ok_or_else(|| {
Failure::usage(
"query.path_missing",
"running a file of statements needs the file to run",
)
.with_hint("name one as the first word, as in `query file carga.sql`")
})
}
fn routine_to_call(args: &CallArgs) -> Result<String> {
args.routine.clone().ok_or_else(|| {
Failure::usage(
"query.routine_missing",
"calling a routine needs the routine to call",
)
.with_hint("name one as the first word, as in `query call recalcular_saldo`")
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_run_of_a_file_without_the_file_is_refused_with_a_code() {
let failure = file_to_run(&FileArgs {
on_error: None,
path: None,
delimiter: None,
})
.expect_err("must refuse");
assert_eq!(failure.code(), "query.path_missing");
assert_eq!(failure.exit_number().code(), 2);
assert!(failure
.hint()
.is_some_and(|hint| hint.contains("query file")));
}
#[test]
fn a_call_without_a_routine_is_refused_with_a_code() {
let failure = routine_to_call(&CallArgs {
outputs: Vec::new(),
routine: None,
params: Vec::new(),
})
.expect_err("must refuse");
assert_eq!(failure.code(), "query.routine_missing");
assert_eq!(failure.exit_number().code(), 2);
assert!(failure
.hint()
.is_some_and(|hint| hint.contains("query call")));
}
#[test]
fn a_block_with_no_statement_is_refused_before_the_block_is_opened() {
let empty = TxArgs {
file: None,
statements: Vec::new(),
stdin: false,
};
let failure = block_statements(&empty, false, crate::exec::DEFAULT_MAX_INPUT_BYTES)
.expect_err("must refuse");
assert_eq!(failure.code(), "usage.no_statement");
assert_eq!(failure.exit_number().code(), 2);
}
#[test]
fn statements_given_on_the_command_line_are_taken_in_the_order_written() {
let written = TxArgs {
file: None,
statements: vec!["SELECT 1".to_owned(), "SELECT 2".to_owned()],
stdin: false,
};
assert_eq!(
block_statements(&written, false, crate::exec::DEFAULT_MAX_INPUT_BYTES)
.expect("both given"),
vec!["SELECT 1".to_owned(), "SELECT 2".to_owned()]
);
}
}