1use super::prepare::Gated;
23use super::read;
24use crate::conn::OrFailure;
25use crate::error::{Failure, Result};
26use crate::output::Row;
27use crate::sql::ident;
28use mysql_async::prelude::Queryable;
29use mysql_async::prelude::*;
30use mysql_async::Conn;
31use serde_json::{json, Value};
32
33#[derive(Debug, Clone, PartialEq, Eq)]
35pub struct ResultSet {
36 pub index: usize,
38 pub columns: Vec<String>,
40 pub rows: Vec<Row>,
42}
43
44impl ResultSet {
45 #[must_use]
47 pub fn as_value(&self) -> Value {
48 json!({
49 "set": self.index,
50 "columns": self.columns,
51 "rows": self.rows,
52 })
53 }
54}
55
56pub fn build(routine: &str, database: Option<&str>, arguments: usize) -> Result<String> {
63 let name = match database {
64 Some(database) => ident::quote_qualified(&[database, routine])?,
65 None => ident::quote(routine)?,
66 };
67 let markers = vec!["?"; arguments].join(", ");
68 Ok(format!("CALL {name}({markers})"))
69}
70
71pub async fn execute(
79 conn: &mut Conn,
80 gated: &Gated,
81 conversion: &crate::types::Conversion,
82) -> Result<Vec<ResultSet>> {
83 let mut result = conn
84 .exec_iter(gated.sql(), gated.params())
85 .await
86 .or_failure()?;
87
88 let mut sets = Vec::new();
89 while !result.is_empty() {
90 let columns = result.columns_ref().to_vec();
91 let labels = read::column_names(&columns);
94 let mut rows = Vec::new();
95 while let Some(row) = result.next().await.or_failure()? {
96 rows.push(read::convert_row(row, &columns, &labels, conversion)?);
97 }
98 if !columns.is_empty() {
101 sets.push(ResultSet {
102 index: sets.len() + 1,
103 columns: labels,
104 rows,
105 });
106 }
107 }
108 Ok(sets)
109}
110
111pub fn refuse_statement_as_name(routine: &str) -> Result<()> {
121 if !routine.contains(char::is_whitespace) && !routine.contains('(') {
122 return Ok(());
123 }
124 Err(Failure::usage(
125 "usage.not_a_routine_name",
126 format!("`{routine}` is a statement, and this command takes the name of a routine"),
127 )
128 .with_detail("detail", routine)
129 .with_hint("give the routine name alone, and its arguments with --param"))
130}
131
132const SIGNATURE: &str = "SELECT ORDINAL_POSITION, PARAMETER_NAME, PARAMETER_MODE \
134 FROM information_schema.PARAMETERS \
135 WHERE SPECIFIC_SCHEMA = COALESCE(:database, DATABASE()) \
136 AND SPECIFIC_NAME = :routine AND ORDINAL_POSITION > 0 \
137 ORDER BY ORDINAL_POSITION";
138
139#[derive(Debug, Clone)]
141pub struct Parameter {
142 pub position: usize,
144 pub name: String,
146 pub mode: String,
148}
149
150impl Parameter {
151 #[must_use]
153 pub fn carries_out(&self) -> bool {
154 let mode = self.mode.to_uppercase();
155 mode == "OUT" || mode == "INOUT"
156 }
157}
158
159pub async fn signature(
168 conn: &mut Conn,
169 database: Option<&str>,
170 routine: &str,
171) -> Result<Vec<Parameter>> {
172 let rows: Vec<(u32, Option<String>, Option<String>)> = conn
173 .exec(
174 SIGNATURE,
175 mysql_async::params! {
176 "database" => database,
177 "routine" => routine,
178 },
179 )
180 .await
181 .or_failure()?;
182
183 Ok(rows
184 .into_iter()
185 .map(|(position, name, mode)| Parameter {
186 position: position as usize,
187 name: name.unwrap_or_default(),
188 mode: mode.unwrap_or_default(),
189 })
190 .collect())
191}
192
193#[derive(Debug, Clone)]
195pub struct Planned {
196 pub sql: String,
198 pub bound: Vec<String>,
200 pub outputs: Vec<(String, String)>,
202}
203
204pub fn plan(
223 routine: &str,
224 database: Option<&str>,
225 declared: &[Parameter],
226 asked: &[String],
227 values: &[String],
228) -> Result<Planned> {
229 let mut wanted = Vec::new();
230 for name in asked {
231 let found = declared
232 .iter()
233 .find(|parameter| parameter.name.eq_ignore_ascii_case(name) && parameter.carries_out());
234 let Some(parameter) = found else {
235 return Err(Failure::validation(
236 "sql.unknown_out_parameter",
237 format!("`{name}` is not an output parameter of this routine"),
238 )
239 .with_detail("detail", name.clone())
240 .with_hint(
241 "read the signature with `schema routines` and mark a parameter the routine declares as OUT or INOUT",
242 ));
243 };
244 wanted.push(parameter.clone());
245 }
246
247 let name = match database {
248 Some(database) => ident::quote_qualified(&[database, routine])?,
249 None => ident::quote(routine)?,
250 };
251 let mut pieces = Vec::new();
252 let mut outputs = Vec::new();
253 for parameter in declared {
254 match wanted.iter().find(|out| out.position == parameter.position) {
255 Some(out) => {
256 let variable = format!("@mariadb_cli_out_{}", out.position);
257 pieces.push(variable.clone());
258 outputs.push((variable, out.name.clone()));
259 }
260 None => pieces.push("?".to_owned()),
261 }
262 }
263
264 Ok(Planned {
265 sql: format!("CALL {name}({})", pieces.join(", ")),
266 bound: values.to_vec(),
267 outputs,
268 })
269}
270
271async fn collected(
280 conn: &mut Conn,
281 outputs: &[(String, String)],
282 conversion: &crate::types::Conversion,
283) -> Result<Row> {
284 if outputs.is_empty() {
285 return Ok(Row::new());
286 }
287 let projection = outputs
288 .iter()
289 .map(|(variable, name)| ident::quote(name).map(|alias| format!("{variable} AS {alias}")))
290 .collect::<Result<Vec<_>>>()?
291 .join(", ");
292
293 let mut result = conn
294 .exec_iter(format!("SELECT {projection}"), mysql_async::Params::Empty)
295 .await
296 .or_failure()?;
297 let columns = result.columns_ref().to_vec();
298 let Some(row) = result.next().await.or_failure()? else {
299 return Ok(Row::new());
300 };
301 let labels = read::column_names(&columns);
302 read::convert_row(row, &columns, &labels, conversion)
303}
304
305#[derive(Debug, Clone, Copy)]
312pub struct Call<'a> {
313 pub routine: &'a str,
315 pub database: Option<&'a str>,
317 pub values: &'a [String],
319 pub outputs: &'a [String],
321}
322
323pub async fn serve(
334 call: Call<'_>,
335 conn: &mut Conn,
336 policy: &super::Policy,
337 write_state: &mut super::WriteState,
338 server_read_only: bool,
339 conversion: &crate::types::Conversion,
340) -> Result<Value> {
341 refuse_statement_as_name(call.routine)?;
342 policy.admit_change("query call")?;
343 policy.admit_simulation("query call")?;
345 write_state.admit(server_read_only)?;
346
347 if call.outputs.is_empty() {
348 let request = build(call.routine, call.database, call.values.len())?;
349 let gated = super::prepare::gate(&request, call.values, policy)?;
350 let sets = execute(conn, &gated, conversion).await?;
351 return Ok(as_value(call.routine, call.database, &sets, &Row::new()));
352 }
353
354 let declared = signature(conn, call.database, call.routine).await?;
358 let planned = plan(
359 call.routine,
360 call.database,
361 &declared,
362 call.outputs,
363 call.values,
364 )?;
365 let gated = super::prepare::gate(&planned.sql, &planned.bound, policy)?;
366 let sets = execute(conn, &gated, conversion).await?;
367 let returned = collected(conn, &planned.outputs, conversion).await?;
368 Ok(as_value(call.routine, call.database, &sets, &returned))
369}
370
371#[must_use]
373pub fn as_value(
374 routine: &str,
375 database: Option<&str>,
376 sets: &[ResultSet],
377 returned: &Row,
378) -> Value {
379 json!({
380 "database": database,
385 "routine": routine,
386 "sets": sets.iter().map(ResultSet::as_value).collect::<Vec<_>>(),
387 "set_count": sets.len(),
388 "output_parameters": returned,
389 })
390}
391
392#[cfg(test)]
393mod tests {
394 use super::*;
395
396 #[test]
397 fn a_call_binds_one_marker_for_every_argument() {
398 assert_eq!(
399 build("recalcular", None, 0).expect("builds"),
400 "CALL `recalcular`()"
401 );
402 assert_eq!(
403 build("recalcular", None, 1).expect("builds"),
404 "CALL `recalcular`(?)"
405 );
406 assert_eq!(
407 build("recalcular", None, 3).expect("builds"),
408 "CALL `recalcular`(?, ?, ?)"
409 );
410 }
411
412 #[test]
413 fn the_database_holding_the_routine_is_quoted_part_by_part() {
414 assert_eq!(
415 build("recalcular", Some("loja"), 1).expect("builds"),
416 "CALL `loja`.`recalcular`(?)"
417 );
418 }
419
420 #[test]
423 fn a_routine_name_can_never_close_its_own_quoting() {
424 let built = build("p`(); DROP TABLE users; -- ", None, 0).expect("quotes");
425 assert_eq!(built, "CALL `p``(); DROP TABLE users; -- `()");
426 assert_eq!(
427 built.matches("``").count(),
428 1,
429 "the delimiter inside the name is doubled, not closed"
430 );
431 }
432
433 #[test]
434 fn a_name_that_cannot_be_quoted_is_refused_rather_than_pasted() {
435 assert!(build("", None, 0).is_err());
436 assert!(build("has\u{0}a control", None, 0).is_err());
437 }
438
439 #[test]
440 fn a_whole_statement_where_a_name_belongs_is_refused_with_the_real_reason() {
441 let failure = refuse_statement_as_name("CALL recalcular(1)").expect_err("must refuse");
442 assert_eq!(failure.code(), "usage.not_a_routine_name");
443 assert_eq!(failure.exit_number().code(), 2);
444 }
445
446 #[test]
447 fn a_plain_routine_name_passes() {
448 assert!(refuse_statement_as_name("recalcular").is_ok());
449 assert!(refuse_statement_as_name("loja.recalcular").is_ok());
450 }
451
452 #[test]
455 fn two_result_sets_reach_the_caller_as_two() {
456 let sets = vec![
457 ResultSet {
458 index: 1,
459 columns: vec!["a".to_owned()],
460 rows: vec![Row::new()],
461 },
462 ResultSet {
463 index: 2,
464 columns: vec!["b".to_owned()],
465 rows: Vec::new(),
466 },
467 ];
468 let value = as_value("recalcular", Some("loja"), &sets, &Row::new());
469 assert_eq!(
470 value["database"], "loja",
471 "the answer must say which database the routine ran in"
472 );
473 assert_eq!(value["set_count"], 2);
474 assert_eq!(value["sets"][0]["set"], 1);
475 assert_eq!(value["sets"][0]["columns"][0], "a");
476 assert_eq!(value["sets"][1]["set"], 2);
477 assert_eq!(value["sets"][1]["columns"][0], "b");
478 }
479
480 #[test]
481 fn a_routine_that_answers_with_nothing_says_so_without_inventing_a_set() {
482 let value = as_value("recalcular", None, &[], &Row::new());
483 assert_eq!(value["set_count"], 0);
484 assert_eq!(value["sets"].as_array().expect("array").len(), 0);
485 }
486}