use super::prepare::Gated;
use crate::conn::OrFailure;
use crate::error::{Failure, Result};
use crate::output::envelope::Gap;
use crate::output::ops::Step;
use crate::output::stream::Stream;
use crate::output::Row;
use crate::sql::classify::Classification;
use crate::sql::{rewrite, ParseLimits};
use crate::types::{value::convert, Conversion};
use mysql_async::prelude::Queryable;
use mysql_async::{Column, Conn, Row as WireRow};
use std::io::Write;
#[derive(Debug, Default)]
pub struct ReadResult {
pub rows: Vec<Row>,
pub columns: Vec<String>,
pub gap: Option<Gap>,
}
pub fn convert_row(
row: WireRow,
columns: &[Column],
labels: &[String],
conversion: &Conversion,
) -> Result<Row> {
let mut converted = Row::with_capacity(columns.len());
let mut wire = row;
for ((index, column), label) in columns.iter().enumerate().zip(labels) {
let value = wire.take(index).unwrap_or(mysql_async::Value::NULL);
converted.insert(label.clone(), convert(&value, column, conversion)?);
}
Ok(converted)
}
const UNNAMED_COLUMN: &str = "column";
const POSITION_MARK: char = '#';
#[must_use]
pub fn column_names(columns: &[Column]) -> Vec<String> {
let mut labels: Vec<String> = columns.iter().map(plain_label).collect();
for index in repeated(&labels) {
labels[index] = qualified_label(&columns[index]);
}
for index in repeated(&labels) {
labels[index] = format!("{}{POSITION_MARK}{index}", labels[index]);
}
labels
}
fn plain_label(column: &Column) -> String {
let name = column.name_str();
if name.is_empty() {
return UNNAMED_COLUMN.to_owned();
}
name.into_owned()
}
fn qualified_label(column: &Column) -> String {
let mut parts: Vec<String> = Vec::with_capacity(3);
for part in [column.schema_str(), column.table_str()] {
if !part.is_empty() {
parts.push(part.into_owned());
}
}
parts.push(plain_label(column));
parts.join(".")
}
fn repeated(labels: &[String]) -> Vec<usize> {
let mut seen: std::collections::HashMap<&str, usize> =
std::collections::HashMap::with_capacity(labels.len());
for label in labels {
*seen.entry(label.as_str()).or_insert(0) += 1;
}
labels
.iter()
.enumerate()
.filter(|(_, label)| seen.get(label.as_str()).is_some_and(|count| *count > 1))
.map(|(index, _)| index)
.collect()
}
pub fn with_ceiling(gated: Gated, ceiling: usize, parse: ParseLimits) -> Result<Gated> {
if gated.classification() != Classification::Read || gated.kind() != "select" {
return Ok(gated);
}
let widened = rewrite::with_limit(gated.sql(), witness_limit(ceiling), None, parse)?;
Ok(gated.with_sql(widened))
}
fn witness_limit(ceiling: usize) -> usize {
ceiling.saturating_add(1)
}
pub async fn collect(
conn: &mut Conn,
gated: &Gated,
ceiling: usize,
conversion: &Conversion,
) -> Result<ReadResult> {
let mut result = conn
.exec_iter(gated.sql(), gated.params())
.await
.or_failure()?;
let columns = result.columns_ref().to_vec();
let labels = column_names(&columns);
let mut under = UnderCeiling::new(ceiling);
while let Some(row) = result.next().await.or_failure()? {
under.take(|| convert_row(row, &columns, &labels, conversion))?;
}
Ok(ReadResult {
columns: labels,
gap: under.gap(),
rows: under.rows,
})
}
#[derive(Debug)]
struct UnderCeiling {
ceiling: usize,
rows: Vec<Row>,
overflowed: bool,
}
impl UnderCeiling {
fn new(ceiling: usize) -> Self {
Self {
ceiling,
rows: Vec::new(),
overflowed: false,
}
}
fn take<F>(&mut self, produce: F) -> Result<()>
where
F: FnOnce() -> Result<Row>,
{
if self.rows.len() < self.ceiling {
self.rows.push(produce()?);
} else {
self.overflowed = true;
}
Ok(())
}
fn gap(&self) -> Option<Gap> {
self.overflowed.then(|| ceiling_gap(self.ceiling))
}
}
fn refuse_a_projection_that_keeps_nothing(
pipeline: &crate::output::Pipeline,
labels: &[String],
shown: &[String],
) -> Result<()> {
if pipeline.select.is_empty() || labels.is_empty() || !shown.is_empty() {
return Ok(());
}
Err(Failure::usage(
"usage.projection_kept_nothing",
"no field named by the projection is carried by the answer",
)
.with_detail("asked", pipeline.select.join(","))
.with_detail("available", labels.join(","))
.with_hint("name a field the answer carries, or leave --select out"))
}
fn ceiling_gap(ceiling: usize) -> Gap {
Gap::new(
"rows",
"row_ceiling",
format!(
"the ceiling of {ceiling} rows was reached and at least one further row was not returned"
),
)
}
pub async fn stream<W: Write>(
conn: &mut Conn,
gated: &Gated,
sink: crate::output::stream::Sink<'_, W>,
pipeline: &crate::output::Pipeline,
conversion: &Conversion,
ceiling: usize,
token: &tokio_util::sync::CancellationToken,
) -> Result<u64> {
let crate::output::stream::Sink {
writer,
formatter,
tail,
} = sink;
let mut result = conn
.exec_iter(gated.sql(), gated.params())
.await
.or_failure()?;
let columns = result.columns_ref().to_vec();
let labels = column_names(&columns);
let shown = pipeline.columns_after_projection(&labels);
refuse_a_projection_that_keeps_nothing(pipeline, &labels, &shown)?;
let mut formatter = formatter;
let mut stage = pipeline.flow_framed(
&mut *formatter,
tail,
&shown,
ceiling,
&[ceiling_gap(ceiling)],
)?;
let mut flow = Stream::open(writer, formatter, tail, &shown)?;
let mut arrived = 0usize;
let mut cut = None;
while let Some(row) = result.next().await.or_failure()? {
if token.is_cancelled() {
return Err(crate::error::Failure::interrupted(
"interrupted.during_flow",
"the invocation was stopped while the rows were still arriving",
));
}
if arrived == ceiling {
cut = Some(ceiling_gap(ceiling));
break;
}
arrived += 1;
match stage.offer(convert_row(row, &columns, &labels, conversion)?) {
Step::Emit(shaped) => flow.write(&shaped)?,
Step::Skip => {}
Step::Stop => {
return flow.finish(tail, &[], stage.applied().as_ref());
}
}
}
flow.finish(tail, cut.as_slice(), stage.applied().as_ref())
}
pub async fn serve(
gated: Gated,
conn: &mut Conn,
parse: ParseLimits,
ceiling: usize,
conversion: &Conversion,
passed_over: usize,
) -> Result<(serde_json::Value, Vec<Gap>)> {
let reach = ceiling.saturating_add(passed_over);
let widened = with_ceiling(gated, reach, parse)?;
let result = collect(conn, &widened, reach, conversion).await?;
Ok((
serde_json::json!({
"columns": result.columns,
"rows": result.rows,
"row_count": result.rows.len(),
}),
result.gap.into_iter().collect(),
))
}
pub fn sample_request(
table: &str,
database: Option<&str>,
wanted: usize,
ceiling: usize,
) -> Result<String> {
if wanted > ceiling {
return Err(Failure::limit(
"limit.rows",
format!("{wanted} rows were asked for and the ceiling is {ceiling}"),
)
.with_detail("detail", format!("{wanted} > {ceiling}"))
.with_hint("ask for fewer rows, or raise output.max_rows"));
}
let name = match database {
Some(database) => crate::sql::ident::quote_qualified(&[database, table])?,
None => crate::sql::ident::quote(table)?,
};
Ok(format!("SELECT * FROM {name}"))
}
pub fn refuse_if_not_a_read(gated: &Gated) -> Result<()> {
if gated.classification().is_read() {
return Ok(());
}
Err(Failure::validation(
"sql.not_a_read",
format!(
"this command only reads, and the statement is a {}",
gated.classification().as_str()
),
)
.with_detail("detail", gated.classification().as_str())
.with_hint("use `query run` for a statement that changes the server"))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::cli::globals::RowCountMode;
use crate::exec::{prepare, Policy};
use crate::output::format::ndjson::Ndjson;
use crate::output::format::{END_OF_STREAM_KEY, ROW_COUNT_KEY};
use serde_json::json;
use std::time::Duration;
fn tail() -> crate::output::Envelope {
crate::output::Envelope::new("query run", json!({}))
}
fn policy() -> Policy {
Policy::new(
ParseLimits::default(),
100,
50,
RowCountMode::Changed,
";".to_owned(),
Duration::from_secs(30),
)
}
fn gated(sql: &str) -> Gated {
prepare::gate(sql, &[], &policy()).expect("admitted")
}
fn row(index: u64) -> Row {
let mut row = Row::new();
row.insert("id".to_owned(), json!(index));
row
}
fn arriving(ceiling: usize, rows: u64) -> UnderCeiling {
let mut under = UnderCeiling::new(ceiling);
for index in 0..rows {
under.take(|| Ok(row(index))).expect("a row is built");
}
under
}
#[test]
fn a_query_receives_this_tools_ceiling_plus_the_witness_row() {
let widened = with_ceiling(gated("SELECT a FROM t"), 5, ParseLimits::default())
.expect("a query accepts a ceiling");
assert_eq!(widened.sql(), "SELECT a FROM t\nLIMIT 6");
}
#[test]
fn a_ceiling_at_the_top_of_the_range_does_not_wrap_around() {
assert_eq!(witness_limit(usize::MAX), usize::MAX);
}
#[test]
fn an_answer_that_fills_the_ceiling_exactly_declares_no_gap() {
let under = arriving(3, 3);
assert_eq!(under.rows.len(), 3);
assert!(under.gap().is_none());
}
#[test]
fn the_witness_row_declares_the_gap_and_is_not_returned() {
let under = arriving(3, 4);
assert_eq!(under.rows.len(), 3, "the caller gets the ceiling, no more");
let gap = under.gap().expect("a cut answer declares its gap");
assert_eq!(gap.object, "rows");
assert_eq!(gap.cause, "row_ceiling");
}
#[test]
fn the_witness_row_never_appears_among_the_returned_rows() {
let under = arriving(3, 4);
let returned: Vec<_> = under.rows.iter().map(|row| row["id"].clone()).collect();
assert_eq!(returned, vec![json!(0), json!(1), json!(2)]);
}
#[test]
fn a_statement_that_is_not_a_query_is_left_exactly_as_written() {
for sql in ["SHOW TABLES", "DESCRIBE t"] {
let untouched =
with_ceiling(gated(sql), 5, ParseLimits::default()).expect("left as written");
assert_eq!(untouched.sql(), sql, "input {sql:?}");
}
}
#[test]
fn a_statement_that_changes_the_server_is_refused_by_a_read_command() {
let failure = refuse_if_not_a_read(&gated("DELETE FROM t WHERE a = 1"))
.expect_err("a change is not a read");
assert_eq!(failure.code(), "sql.not_a_read");
assert!(failure.message().contains("change"));
}
#[test]
fn a_read_passes_the_read_only_refusal() {
assert!(refuse_if_not_a_read(&gated("SELECT 1")).is_ok());
}
#[test]
fn a_ceiling_that_cuts_the_answer_declares_the_gap_it_left() {
let gap = ceiling_gap(10);
assert_eq!(gap.object, "rows");
assert_eq!(gap.cause, "row_ceiling");
assert!(gap.detail.contains("10"), "the ceiling is named");
assert!(
gap.detail.contains("at least one"),
"no count is invented: {}",
gap.detail
);
}
#[test]
fn a_completed_flow_ends_with_the_record_that_declares_it_whole() {
let mut out = Vec::new();
let mut flow =
Stream::open(&mut out, Box::new(Ndjson), &tail(), &["id".to_owned()]).expect("opens");
for index in 0..3 {
flow.write(&row(index)).expect("writes");
}
assert_eq!(flow.finish(&tail(), &[], None).expect("closes"), 3);
let text = String::from_utf8(out).expect("utf8");
let last = text.lines().next_back().expect("a last line");
let parsed: serde_json::Value = serde_json::from_str(last).expect("parses");
assert_eq!(parsed[END_OF_STREAM_KEY], true);
assert_eq!(parsed[ROW_COUNT_KEY], 3);
}
#[test]
fn a_flow_abandoned_mid_way_carries_no_closing_record() {
let mut out = Vec::new();
{
let mut flow = Stream::open(&mut out, Box::new(Ndjson), &tail(), &["id".to_owned()])
.expect("opens");
flow.write(&row(0)).expect("writes");
}
let text = String::from_utf8(out).expect("utf8");
assert!(
!text.contains(END_OF_STREAM_KEY),
"a cut set must never look whole: {text}"
);
}
fn declared(schema: &str, table: &str, name: &str) -> Column {
Column::new(mysql_async::consts::ColumnType::MYSQL_TYPE_LONG)
.with_schema(schema.as_bytes())
.with_table(table.as_bytes())
.with_name(name.as_bytes())
}
#[test]
fn fr_102_two_homonymous_columns_keep_two_distinct_labels() {
let labels = column_names(&[
declared("loja", "pedidos", "id"),
declared("loja", "clientes", "id"),
]);
assert_eq!(labels, vec!["loja.pedidos.id", "loja.clientes.id"]);
}
#[test]
fn fr_102_a_name_that_repeats_nowhere_is_left_as_declared() {
let labels = column_names(&[
declared("loja", "pedidos", "total"),
declared("loja", "clientes", "nome"),
]);
assert_eq!(labels, vec!["total", "nome"]);
}
#[test]
fn fr_102_a_self_join_falls_back_to_the_declared_position() {
let labels = column_names(&[
declared("loja", "pedidos", "id"),
declared("loja", "pedidos", "id"),
]);
assert_eq!(labels, vec!["loja.pedidos.id#0", "loja.pedidos.id#1"]);
}
#[test]
fn fr_102_a_column_with_no_declared_name_still_gets_one() {
let labels = column_names(&[declared("", "", ""), declared("", "", "")]);
assert_eq!(labels, vec!["column#0", "column#1"]);
}
#[test]
fn fr_102_the_labels_are_the_same_on_every_run() {
let columns = [
declared("loja", "pedidos", "id"),
declared("loja", "clientes", "id"),
declared("", "", ""),
];
assert_eq!(column_names(&columns), column_names(&columns));
}
#[test]
fn fr_102_a_qualified_label_that_meets_a_plain_one_is_still_separated() {
let labels = column_names(&[
declared("", "pedidos", "id"),
declared("", "clientes", "id"),
declared("", "", "pedidos.id"),
]);
assert_eq!(
labels,
vec!["pedidos.id#0", "clientes.id", "pedidos.id#2"],
"no two columns may share a label"
);
}
#[test]
fn a_long_flow_does_not_grow_its_buffer_row_by_row() {
let mut out = Vec::new();
let mut flow =
Stream::open(&mut out, Box::new(Ndjson), &tail(), &["id".to_owned()]).expect("opens");
let before = flow.buffer_capacity();
for index in 0..20_000 {
flow.write(&row(index)).expect("writes");
}
assert_eq!(flow.buffer_capacity(), before);
assert_eq!(flow.finish(&tail(), &[], None).expect("closes"), 20_000);
}
}