use crate::error::{Failure, Result};
use crate::sql::strip::strip;
const DIRECTIVE: &str = "delimiter";
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Piece {
pub index: usize,
pub line: usize,
pub sql: String,
}
pub fn validate_delimiter(delimiter: &str) -> Result<()> {
if delimiter.trim().is_empty() {
return Err(Failure::usage(
"usage.empty_delimiter",
"the statement separator is empty, so it could never separate anything",
)
.with_hint("give a separator such as ; or $$"));
}
Ok(())
}
pub fn split<'a>(text: &'a str, delimiter: &str) -> Result<Statements<'a>> {
validate_delimiter(delimiter)?;
let blanked = strip(text);
blanked.refuse_if_unterminated()?;
let mut cut = Cut::new(text, blanked.text().to_owned(), delimiter);
while cut.next_piece().is_some() {}
if let Some(line) = cut.redefined_at {
return Err(Failure::validation(
"script.delimiter_not_restored",
format!("the separator was redefined on line {line} and never restored"),
)
.with_detail("detail", format!("L{line}"))
.with_hint("add a line restoring the separator before the file ends"));
}
cut.rewind();
Ok(Statements { cut })
}
#[derive(Debug)]
pub struct Statements<'a> {
cut: Cut<'a>,
}
impl Iterator for Statements<'_> {
type Item = Piece;
fn next(&mut self) -> Option<Piece> {
self.cut.next_piece()
}
}
#[derive(Debug)]
struct Cut<'a> {
original: &'a str,
masked: String,
initial: String,
active: String,
redefined_at: Option<usize>,
start: usize,
offset: usize,
cursor: Option<usize>,
line_end: usize,
handed_out: usize,
spent: bool,
breaks_before: usize,
counted_upto: usize,
}
impl<'a> Cut<'a> {
fn new(original: &'a str, masked: String, delimiter: &str) -> Self {
Self {
original,
masked,
initial: delimiter.to_owned(),
active: delimiter.to_owned(),
redefined_at: None,
start: 0,
offset: 0,
cursor: None,
line_end: 0,
handed_out: 0,
spent: false,
breaks_before: 0,
counted_upto: 0,
}
}
fn rewind(&mut self) {
self.active.clone_from(&self.initial);
self.redefined_at = None;
self.start = 0;
self.offset = 0;
self.cursor = None;
self.line_end = 0;
self.handed_out = 0;
self.spent = false;
self.breaks_before = 0;
self.counted_upto = 0;
}
fn next_piece(&mut self) -> Option<Piece> {
loop {
if self.spent {
return None;
}
if self.offset >= self.masked.len() {
self.spent = true;
return self.take(self.start..self.original.len());
}
let Some(cursor) = self.cursor else {
self.line_end = self.masked[self.offset..]
.find('\n')
.map_or(self.masked.len(), |found| self.offset + found);
if self.take_directive(self.offset, self.line_end) {
self.offset = self.line_end + 1;
} else {
self.cursor = Some(self.offset);
}
continue;
};
let Some(found) = self.masked[cursor..self.line_end].find(self.active.as_str()) else {
self.cursor = None;
self.offset = self.line_end + 1;
continue;
};
let at = cursor + found;
let region = self.start..at;
self.cursor = Some(at + self.active.len());
self.start = at + self.active.len();
if let Some(piece) = self.take(region) {
return Some(piece);
}
}
}
fn take_directive(&mut self, from: usize, to: usize) -> bool {
if !self.masked[self.start..from].trim().is_empty() {
return false;
}
let line = self.masked[from..to].trim_start();
let leading = to - from - line.len();
if line.len() < DIRECTIVE.len()
|| !line[..DIRECTIVE.len()].eq_ignore_ascii_case(DIRECTIVE)
|| !line[DIRECTIVE.len()..].starts_with(char::is_whitespace)
{
return false;
}
let declared = self.original[from + leading + DIRECTIVE.len()..to].trim();
if declared.is_empty() {
return false;
}
self.active = declared.to_owned();
self.redefined_at = (self.active != self.initial).then(|| self.line_of(from));
self.start = to.min(self.masked.len());
true
}
fn take(&mut self, region: std::ops::Range<usize>) -> Option<Piece> {
let whole = &self.original[region.clone()];
let text = whole.trim();
if text.is_empty() {
return None;
}
let leading = whole.len() - whole.trim_start().len();
let sql = text.to_owned();
let line = self.line_of(region.start + leading);
self.handed_out += 1;
Some(Piece {
index: self.handed_out,
line,
sql,
})
}
fn line_of(&mut self, offset: usize) -> usize {
if offset < self.counted_upto {
self.counted_upto = 0;
self.breaks_before = 0;
}
self.breaks_before += self.original[self.counted_upto..offset]
.matches('\n')
.count();
self.counted_upto = offset;
self.breaks_before + 1
}
}
#[cfg(test)]
mod tests {
use super::*;
fn pieces(text: &str, delimiter: &str) -> Vec<Piece> {
split(text, delimiter)
.expect("the file must split")
.collect()
}
fn statements(text: &str, delimiter: &str) -> Vec<String> {
pieces(text, delimiter).into_iter().map(|p| p.sql).collect()
}
#[test]
fn a_file_is_cut_at_every_separator_and_each_piece_knows_its_position() {
let cut = pieces("SELECT 1;\nSELECT 2;\n", ";");
assert_eq!(cut.len(), 2);
assert_eq!(
cut[0],
Piece {
index: 1,
line: 1,
sql: "SELECT 1".to_owned()
}
);
assert_eq!(
cut[1],
Piece {
index: 2,
line: 2,
sql: "SELECT 2".to_owned()
}
);
assert_eq!(
statements("SELECT 1;\nSELECT 2", ";"),
vec!["SELECT 1".to_owned(), "SELECT 2".to_owned()],
"a last statement written without a separator is not lost"
);
for nothing in ["", "\n\n \n", ";;;"] {
assert!(pieces(nothing, ";").is_empty(), "input {nothing:?}");
}
}
#[test]
fn a_separator_that_is_not_one_never_cuts_the_file() {
for (file, whole) in [
("SELECT 'a;b' AS note;\n", "SELECT 'a;b' AS note"),
("SELECT 1 AS `a;b`;\n", "SELECT 1 AS `a;b`"),
("SELECT 1 -- ; not a cut\n;\n", "SELECT 1 -- ; not a cut"),
("SELECT /* ; */ 1;\n", "SELECT /* ; */ 1"),
] {
assert_eq!(
statements(file, ";"),
vec![whole.to_owned()],
"input {file:?}"
);
}
}
#[test]
fn a_routine_body_with_inner_separators_reaches_the_server_whole() {
let file = "DELIMITER $$\n\
CREATE PROCEDURE p()\n\
BEGIN\n\
SELECT 1;\n\
SELECT 2;\n\
END$$\n\
DELIMITER ;\n\
SELECT 3;\n";
let cut = statements(file, ";");
assert_eq!(cut.len(), 2, "the body is one statement, got {cut:?}");
assert!(cut[0].starts_with("CREATE PROCEDURE p()"));
assert!(
cut[0].contains("SELECT 1;") && cut[0].contains("SELECT 2;"),
"the inner separators survive: {}",
cut[0]
);
assert_eq!(cut[1], "SELECT 3");
let unrestored = "SELECT 1;\nDELIMITER $$\nCREATE PROCEDURE p() BEGIN SELECT 1; END$$\n";
let failure = split(unrestored, ";").expect_err("must refuse");
assert_eq!(failure.code(), "script.delimiter_not_restored");
assert!(failure.message().contains('2'), "the line is named");
}
#[test]
fn the_walk_handed_to_the_caller_starts_where_the_file_does() {
let file = "-- a note\nSELECT 1;\n\n\nDELIMITER $$\nSELECT 2$$\nDELIMITER ;\nSELECT 3;\n";
let once = pieces(file, ";");
let twice = pieces(file, ";");
assert_eq!(once, twice, "the same file cut twice is the same cut");
assert_eq!(
once.iter().map(|p| (p.index, p.line)).collect::<Vec<_>>(),
vec![(1, 1), (2, 6), (3, 8)],
"got {once:?}"
);
}
#[test]
fn the_directive_is_never_sent_and_the_same_word_inside_a_statement_is_not_one() {
for statement in statements("DELIMITER $$\nSELECT 1$$\nDELIMITER ;\n", ";") {
assert!(
!statement.to_lowercase().starts_with(DIRECTIVE),
"the directive leaked into a statement: {statement}"
);
}
assert_eq!(
statements("SELECT a\nFROM delimiter x;\n", ";"),
vec!["SELECT a\nFROM delimiter x".to_owned()]
);
assert_eq!(
statements("SELECT 1$$SELECT 2$$", "$$"),
vec!["SELECT 1".to_owned(), "SELECT 2".to_owned()],
"a file may use a separator of its own from the start"
);
}
#[test]
fn a_file_that_could_never_be_split_is_refused_rather_than_cut_into_nonsense() {
let failure = validate_delimiter("").expect_err("must refuse");
assert_eq!(failure.code(), "usage.empty_delimiter");
assert_eq!(failure.exit_number().code(), 2);
assert_eq!(
split("SELECT 1", " ").expect_err("must refuse").code(),
"usage.empty_delimiter"
);
assert_eq!(
split("SELECT 'never closed;\n", ";")
.expect_err("must refuse")
.code(),
"sql.unterminated_region"
);
}
#[test]
fn the_positions_reported_survive_blank_lines_and_comments() {
let file = "-- a note\n\n\nSELECT 1;\n\n-- another\nSELECT 2;\n";
let cut = pieces(file, ";");
assert_eq!(cut[0].line, 1, "a leading comment belongs to the statement");
assert_eq!(cut[1].line, 6);
assert!(cut[1].sql.starts_with("-- another"));
let spaced = pieces("SELECT 1;\n\n\nSELECT 2;\n", ";");
assert_eq!((spaced[0].line, spaced[1].line), (1, 4));
}
}