#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum TxnMode {
AutoCommit,
Explicit {
end: TxnEnd,
},
Session,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum TxnEnd {
Commit,
Cancel,
Unterminated,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum Emission {
#[default]
Stream,
Hold,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum RequestStatementKind {
Begin,
Commit,
Cancel,
Option,
Run,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum MisplacedControl {
NestedBegin,
BeginInSession,
CommitOutsideBlock,
CancelOutsideBlock,
}
impl MisplacedControl {
pub fn message(self) -> &'static str {
match self {
MisplacedControl::NestedBegin => {
"Tried to start a transaction while another transaction was open"
}
MisplacedControl::BeginInSession => "Cannot BEGIN a transaction within a transaction",
MisplacedControl::CommitOutsideBlock => "Cannot COMMIT without starting a transaction",
MisplacedControl::CancelOutsideBlock => "Cannot CANCEL without starting a transaction",
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum StatementRole {
Run,
Option,
Begin,
Commit,
Cancel,
Misplaced(MisplacedControl),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct StatementPlace {
pub index: usize,
pub transaction: usize,
pub role: StatementRole,
pub emission: Emission,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalTransaction {
pub mode: TxnMode,
pub emission: Emission,
pub first_index: usize,
pub statements: Vec<usize>,
pub aborted_at: Option<usize>,
pub misplaced: Vec<(usize, MisplacedControl)>,
start: BlockStart,
}
impl LogicalTransaction {
fn new(mode: TxnMode, first_index: usize) -> Self {
LogicalTransaction {
mode,
emission: Emission::Stream,
first_index,
statements: vec![first_index],
aborted_at: None,
misplaced: Vec::new(),
start: BlockStart::Begin,
}
}
pub fn start(&self) -> BlockStart {
self.start
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum BlockStart {
Begin,
Continued,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct OpenBlock {
block: LogicalTransaction,
next: usize,
}
impl OpenBlock {
pub fn transaction(&self) -> &LogicalTransaction {
&self.block
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct FragmentGrouping {
pub transactions: Vec<LogicalTransaction>,
pub open: Option<OpenBlock>,
}
fn plain_role(kind: RequestStatementKind) -> StatementRole {
match kind {
RequestStatementKind::Option => StatementRole::Option,
RequestStatementKind::Run
| RequestStatementKind::Begin
| RequestStatementKind::Commit
| RequestStatementKind::Cancel => StatementRole::Run,
}
}
#[derive(Debug)]
pub struct RequestGrouper {
session: bool,
explicit_emission: Emission,
next: usize,
out: Vec<LogicalTransaction>,
block: Option<LogicalTransaction>,
held: Option<LogicalTransaction>,
}
impl RequestGrouper {
pub fn new(session: bool) -> Self {
RequestGrouper {
session,
explicit_emission: Emission::Stream,
next: 0,
out: Vec::new(),
block: None,
held: None,
}
}
pub fn resume(session: bool, open: OpenBlock) -> Self {
let OpenBlock {
block,
next,
} = open;
let mut grouper = RequestGrouper::new(session).with_explicit_emission(block.emission);
grouper.next = next;
if !session {
grouper.block = Some(LogicalTransaction {
statements: Vec::new(),
first_index: next,
aborted_at: None,
misplaced: Vec::new(),
start: BlockStart::Continued,
..block
});
}
grouper
}
pub fn with_explicit_emission(mut self, emission: Emission) -> Self {
self.explicit_emission = emission;
self
}
pub fn place(&mut self, kind: RequestStatementKind) -> StatementPlace {
let index = self.next;
self.next += 1;
if self.session {
let role = match kind {
RequestStatementKind::Begin => {
StatementRole::Misplaced(MisplacedControl::BeginInSession)
}
RequestStatementKind::Commit => {
StatementRole::Misplaced(MisplacedControl::CommitOutsideBlock)
}
RequestStatementKind::Cancel => {
StatementRole::Misplaced(MisplacedControl::CancelOutsideBlock)
}
RequestStatementKind::Option => StatementRole::Option,
RequestStatementKind::Run => StatementRole::Run,
};
let held = match &mut self.held {
Some(held) => {
held.statements.push(index);
held
}
none => none.insert(LogicalTransaction::new(TxnMode::Session, index)),
};
if let StatementRole::Misplaced(m) = role {
held.misplaced.push((index, m));
}
return StatementPlace {
index,
transaction: 0,
role,
emission: Emission::Stream,
};
}
match (&mut self.block, kind) {
(Some(open), RequestStatementKind::Commit | RequestStatementKind::Cancel) => {
open.statements.push(index);
let (end, role) = if matches!(kind, RequestStatementKind::Commit) {
(TxnEnd::Commit, StatementRole::Commit)
} else {
(TxnEnd::Cancel, StatementRole::Cancel)
};
open.mode = TxnMode::Explicit {
end,
};
let transaction = self.out.len();
let emission = open.emission;
self.out.extend(self.block.take());
StatementPlace {
index,
transaction,
role,
emission,
}
}
(Some(open), RequestStatementKind::Begin) => {
open.statements.push(index);
open.aborted_at.get_or_insert(index);
open.misplaced.push((index, MisplacedControl::NestedBegin));
StatementPlace {
index,
transaction: self.out.len(),
role: StatementRole::Misplaced(MisplacedControl::NestedBegin),
emission: open.emission,
}
}
(Some(open), RequestStatementKind::Option | RequestStatementKind::Run) => {
open.statements.push(index);
StatementPlace {
index,
transaction: self.out.len(),
role: plain_role(kind),
emission: open.emission,
}
}
(None, RequestStatementKind::Begin) => {
let mut block = LogicalTransaction::new(
TxnMode::Explicit {
end: TxnEnd::Unterminated,
},
index,
);
block.emission = self.explicit_emission;
self.block = Some(block);
StatementPlace {
index,
transaction: self.out.len(),
role: StatementRole::Begin,
emission: self.explicit_emission,
}
}
(
None,
RequestStatementKind::Commit
| RequestStatementKind::Cancel
| RequestStatementKind::Option
| RequestStatementKind::Run,
) => {
let mut txn = LogicalTransaction::new(TxnMode::AutoCommit, index);
let role = match kind {
RequestStatementKind::Commit => {
StatementRole::Misplaced(MisplacedControl::CommitOutsideBlock)
}
RequestStatementKind::Cancel => {
StatementRole::Misplaced(MisplacedControl::CancelOutsideBlock)
}
RequestStatementKind::Option
| RequestStatementKind::Run
| RequestStatementKind::Begin => plain_role(kind),
};
if let StatementRole::Misplaced(m) = role {
txn.misplaced.push((index, m));
}
let transaction = self.out.len();
self.out.push(txn);
StatementPlace {
index,
transaction,
role,
emission: Emission::Stream,
}
}
}
}
pub fn finish(mut self) -> Vec<LogicalTransaction> {
self.out.extend(self.block.take());
self.out.extend(self.held.take());
self.out
}
pub fn finish_fragment(mut self) -> FragmentGrouping {
let open = self.block.take().map(|block| OpenBlock {
block,
next: self.next,
});
self.out.extend(self.held.take());
FragmentGrouping {
transactions: self.out,
open,
}
}
}
pub fn lower_request(kinds: &[RequestStatementKind], session: bool) -> Vec<LogicalTransaction> {
lower_request_with(kinds, session, Emission::Stream)
}
pub fn lower_request_with(
kinds: &[RequestStatementKind],
session: bool,
explicit: Emission,
) -> Vec<LogicalTransaction> {
let mut grouper = RequestGrouper::new(session).with_explicit_emission(explicit);
for kind in kinds {
grouper.place(*kind);
}
grouper.finish()
}
#[cfg(test)]
mod tests {
use super::RequestStatementKind::{Begin, Cancel, Commit, Run};
use super::*;
fn modes(kinds: &[RequestStatementKind]) -> Vec<(TxnMode, Vec<usize>, Option<usize>)> {
lower_request(kinds, false)
.into_iter()
.map(|txn| (txn.mode, txn.statements, txn.aborted_at))
.collect()
}
const AUTO: TxnMode = TxnMode::AutoCommit;
fn explicit(end: TxnEnd) -> TxnMode {
TxnMode::Explicit {
end,
}
}
#[test]
fn each_statement_outside_a_block_is_a_transaction_of_its_own() {
assert_eq!(
modes(&[Run, RequestStatementKind::Option, Run]),
vec![(AUTO, vec![0], None), (AUTO, vec![1], None), (AUTO, vec![2], None)]
);
}
#[test]
fn a_block_runs_from_its_begin_to_the_statement_that_ends_it() {
assert_eq!(
modes(&[Run, Begin, Run, Run, Commit, Run]),
vec![
(AUTO, vec![0], None),
(explicit(TxnEnd::Commit), vec![1, 2, 3, 4], None),
(AUTO, vec![5], None),
]
);
assert_eq!(
modes(&[Begin, Run, Cancel]),
vec![(explicit(TxnEnd::Cancel), vec![0, 1, 2], None)]
);
assert_eq!(modes(&[Begin, Run]), vec![(explicit(TxnEnd::Unterminated), vec![0, 1], None)]);
}
#[test]
fn a_misplaced_transaction_statement_keeps_its_place() {
assert_eq!(
modes(&[Commit, Cancel, Run]),
vec![(AUTO, vec![0], None), (AUTO, vec![1], None), (AUTO, vec![2], None)]
);
assert_eq!(
modes(&[Begin, Run, Begin, Run, Commit, Run]),
vec![(explicit(TxnEnd::Commit), vec![0, 1, 2, 3, 4], Some(2)), (AUTO, vec![5], None)]
);
}
#[test]
fn a_session_transaction_holds_every_statement() {
let txns = lower_request(&[Run, Begin, Run], true);
assert_eq!(txns.len(), 1);
assert_eq!(txns[0].mode, TxnMode::Session);
assert_eq!(txns[0].statements, vec![0, 1, 2]);
}
#[test]
fn every_transaction_streams_by_default() {
for txn in lower_request(&[Run, Begin, Run, Cancel, Begin], false) {
assert_eq!(txn.emission, Emission::Stream);
}
}
#[test]
fn an_explicit_transaction_holds_when_asked() {
let kinds = [Run, Begin, Run, Commit, Begin, Run, Cancel, Begin, Run];
let txns = lower_request_with(&kinds, false, Emission::Hold);
assert_eq!(
txns.iter().map(|txn| txn.emission).collect::<Vec<_>>(),
vec![Emission::Stream, Emission::Hold, Emission::Hold, Emission::Hold]
);
assert_eq!(txns[0].mode, TxnMode::AutoCommit);
assert_eq!(txns[3].mode, explicit(TxnEnd::Unterminated));
}
#[test]
fn auto_commit_and_session_transactions_always_stream() {
for txn in lower_request_with(&[Run, Commit, Run], false, Emission::Hold) {
assert_eq!(txn.emission, Emission::Stream);
}
let txns = lower_request_with(&[Run, Begin, Run, Commit], true, Emission::Hold);
assert_eq!(txns.len(), 1);
assert_eq!(txns[0].mode, TxnMode::Session);
assert_eq!(txns[0].emission, Emission::Stream);
}
#[test]
fn a_place_carries_its_transactions_emission() {
let mut grouper = RequestGrouper::new(false).with_explicit_emission(Emission::Hold);
let emissions: Vec<_> = [Run, Begin, Run, Begin, Commit, Commit]
.iter()
.map(|kind| grouper.place(*kind).emission)
.collect();
assert_eq!(
emissions,
vec![
Emission::Stream,
Emission::Hold,
Emission::Hold,
Emission::Hold,
Emission::Hold,
Emission::Stream
]
);
}
fn roles(kinds: &[RequestStatementKind], session: bool) -> Vec<StatementRole> {
let mut grouper = RequestGrouper::new(session);
kinds.iter().map(|kind| grouper.place(*kind).role).collect()
}
const NESTED: StatementRole = StatementRole::Misplaced(MisplacedControl::NestedBegin);
const STRAY_COMMIT: StatementRole =
StatementRole::Misplaced(MisplacedControl::CommitOutsideBlock);
const STRAY_CANCEL: StatementRole =
StatementRole::Misplaced(MisplacedControl::CancelOutsideBlock);
#[test]
fn a_statement_outside_a_block_has_its_own_role() {
assert_eq!(
roles(&[Run, RequestStatementKind::Option, Commit, Cancel], false),
vec![StatementRole::Run, StatementRole::Option, STRAY_COMMIT, STRAY_CANCEL]
);
}
#[test]
fn a_block_is_opened_and_ended_by_its_own_statements() {
assert_eq!(
roles(&[Begin, Run, RequestStatementKind::Option, Commit], false),
vec![
StatementRole::Begin,
StatementRole::Run,
StatementRole::Option,
StatementRole::Commit
]
);
assert_eq!(
roles(&[Begin, Cancel, Begin, Commit], false),
vec![
StatementRole::Begin,
StatementRole::Cancel,
StatementRole::Begin,
StatementRole::Commit
]
);
}
#[test]
fn a_begin_inside_a_block_is_nested() {
assert_eq!(
roles(&[Begin, Begin, Commit], false),
vec![StatementRole::Begin, NESTED, StatementRole::Commit]
);
}
#[test]
fn a_session_marks_every_transaction_statement() {
assert_eq!(
roles(&[Begin, Run, Commit, Cancel, RequestStatementKind::Option], true),
vec![
StatementRole::Misplaced(MisplacedControl::BeginInSession),
StatementRole::Run,
STRAY_COMMIT,
STRAY_CANCEL,
StatementRole::Option,
]
);
let mut grouper = RequestGrouper::new(true);
for kind in [Run, Begin, Commit, Cancel] {
grouper.place(kind);
}
let txns = grouper.finish();
assert_eq!(txns.len(), 1);
assert_eq!(txns[0].mode, TxnMode::Session);
assert_eq!(txns[0].aborted_at, None);
assert_eq!(
txns[0].misplaced,
vec![
(1, MisplacedControl::BeginInSession),
(2, MisplacedControl::CommitOutsideBlock),
(3, MisplacedControl::CancelOutsideBlock),
]
);
}
#[test]
fn an_empty_session_request_has_no_transaction() {
assert!(RequestGrouper::new(true).finish().is_empty());
assert!(RequestGrouper::new(false).finish().is_empty());
}
#[test]
fn misplaced_statements_are_recorded_on_their_transaction() {
let txns = lower_request(&[Commit, Begin, Begin, Run, Commit, Cancel], false);
assert_eq!(txns.len(), 3);
assert_eq!(txns[0].misplaced, vec![(0, MisplacedControl::CommitOutsideBlock)]);
assert_eq!(txns[1].misplaced, vec![(2, MisplacedControl::NestedBegin)]);
assert_eq!(txns[2].misplaced, vec![(5, MisplacedControl::CancelOutsideBlock)]);
}
#[test]
fn a_second_nested_begin_is_marked_while_the_abort_keeps_the_first() {
let txns = lower_request(&[Begin, Begin, Run, Begin, Commit], false);
assert_eq!(txns.len(), 1);
assert_eq!(txns[0].aborted_at, Some(1));
assert_eq!(
txns[0].misplaced,
vec![(1, MisplacedControl::NestedBegin), (3, MisplacedControl::NestedBegin)]
);
}
#[test]
fn places_are_numbered_without_gaps_and_point_at_their_transaction() {
let kinds = [Run, Begin, Run, Begin, Commit, Commit, Begin, Run];
let mut grouper = RequestGrouper::new(false);
let places: Vec<_> = kinds.iter().map(|kind| grouper.place(*kind)).collect();
let txns = grouper.finish();
assert_eq!(
places.iter().map(|p| p.index).collect::<Vec<_>>(),
(0..kinds.len()).collect::<Vec<_>>()
);
for place in &places {
assert!(txns[place.transaction].statements.contains(&place.index));
}
assert_eq!(
places.iter().map(|p| p.transaction).collect::<Vec<_>>(),
vec![0, 1, 1, 1, 1, 2, 3, 3]
);
}
#[test]
fn lowering_is_the_fold_of_the_grouper() {
let sequences: [&[RequestStatementKind]; 5] = [
&[],
&[Run, Begin, Run, Commit, Cancel],
&[Begin, Begin, Run, Begin],
&[Commit, Begin, Cancel, Begin, Run, Commit],
&[RequestStatementKind::Option, Begin, RequestStatementKind::Option, Cancel],
];
for kinds in sequences {
for session in [false, true] {
let mut grouper = RequestGrouper::new(session);
for kind in kinds {
grouper.place(*kind);
}
assert_eq!(lower_request(kinds, session), grouper.finish());
}
}
}
fn fold_fragments(
kinds: &[RequestStatementKind],
cuts: &[usize],
) -> (Vec<(usize, StatementRole, Emission)>, Vec<LogicalTransaction>, bool) {
let mut bounds = vec![0];
bounds.extend_from_slice(cuts);
bounds.push(kinds.len());
let mut places = Vec::new();
let mut merged: Vec<LogicalTransaction> = Vec::new();
let mut spanned = false;
let mut open: Option<OpenBlock> = None;
let mut base = 0;
for window in bounds.windows(2) {
if open.is_none() {
base = window[0];
}
let mut grouper = match open.take() {
Some(block) => RequestGrouper::resume(false, block),
None => RequestGrouper::new(false),
};
for kind in &kinds[window[0]..window[1]] {
let place = grouper.place(*kind);
places.push((place.index + base, place.role, place.emission));
}
let FragmentGrouping {
transactions,
open: left,
} = grouper.finish_fragment();
let pieces =
transactions.into_iter().chain(left.as_ref().map(|o| o.transaction().clone()));
for mut piece in pieces {
piece.first_index += base;
piece.statements.iter_mut().for_each(|i| *i += base);
piece.aborted_at = piece.aborted_at.map(|i| i + base);
piece.misplaced.iter_mut().for_each(|(i, _)| *i += base);
match (piece.start(), merged.last_mut()) {
(BlockStart::Continued, Some(head)) => {
spanned = true;
head.mode = piece.mode;
head.statements.extend(piece.statements);
head.misplaced.extend(piece.misplaced);
head.aborted_at = head.aborted_at.or(piece.aborted_at);
}
(BlockStart::Continued, None) => {
panic!("a continued block with no block to continue")
}
(BlockStart::Begin, _) => merged.push(piece),
}
}
open = left;
}
(places, merged, spanned)
}
fn whole_places(kinds: &[RequestStatementKind]) -> Vec<(usize, StatementRole, Emission)> {
let mut grouper = RequestGrouper::new(false);
kinds
.iter()
.map(|kind| {
let place = grouper.place(*kind);
(place.index, place.role, place.emission)
})
.collect()
}
#[test]
fn a_fragment_ending_inside_a_block_returns_it_open() {
let mut grouper = RequestGrouper::new(false);
for kind in [Run, Begin, Run] {
grouper.place(kind);
}
let fragment = grouper.finish_fragment();
assert_eq!(fragment.transactions.len(), 1);
assert_eq!(fragment.transactions[0].mode, AUTO);
let open = fragment.open.expect("the block is still open");
assert_eq!(open.transaction().statements, vec![1, 2]);
assert_eq!(open.transaction().start(), BlockStart::Begin);
assert_eq!(open.transaction().mode, explicit(TxnEnd::Unterminated));
let mut grouper = RequestGrouper::new(false);
for kind in [Begin, Commit, Run] {
grouper.place(kind);
}
let fragment = grouper.finish_fragment();
assert_eq!(fragment.transactions.len(), 2);
assert!(fragment.open.is_none());
}
#[test]
fn a_resumed_block_ends_at_the_next_terminator_and_is_continued() {
let mut first = RequestGrouper::new(false);
for kind in [Begin, Run] {
first.place(kind);
}
let open = first.finish_fragment().open.expect("open");
let mut second = RequestGrouper::resume(false, open);
let places: Vec<_> = [Run, Commit, Run].iter().map(|kind| second.place(*kind)).collect();
assert_eq!(places.iter().map(|p| p.index).collect::<Vec<_>>(), vec![2, 3, 4]);
assert_eq!(
places.iter().map(|p| p.role).collect::<Vec<_>>(),
vec![StatementRole::Run, StatementRole::Commit, StatementRole::Run]
);
assert_eq!(places.iter().map(|p| p.transaction).collect::<Vec<_>>(), vec![0, 0, 1]);
let txns = second.finish();
assert_eq!(txns.len(), 2);
assert_eq!(txns[0].start(), BlockStart::Continued);
assert_eq!(txns[0].mode, explicit(TxnEnd::Commit));
assert_eq!(txns[0].statements, vec![2, 3]);
assert_eq!(txns[1].start(), BlockStart::Begin);
assert_eq!(txns[1].mode, AUTO);
}
#[test]
fn a_resumed_block_without_a_terminator_is_unterminated_by_finish_and_open_by_finish_fragment()
{
let mut first = RequestGrouper::new(false);
first.place(Begin);
let open = first.finish_fragment().open.expect("open");
let mut second = RequestGrouper::resume(false, open.clone());
second.place(Run);
let txns = second.finish();
assert_eq!(txns.len(), 1);
assert_eq!(txns[0].start(), BlockStart::Continued);
assert_eq!(txns[0].mode, explicit(TxnEnd::Unterminated));
let mut second = RequestGrouper::resume(false, open);
second.place(Run);
let again = second.finish_fragment();
assert!(again.transactions.is_empty());
let open = again.open.expect("still open");
assert_eq!(open.transaction().start(), BlockStart::Continued);
assert_eq!(open.transaction().statements, vec![1]);
let mut third = RequestGrouper::resume(false, open);
assert_eq!(third.place(Commit).index, 2);
}
#[test]
fn a_resumed_grouper_keeps_the_emission_of_the_block() {
let mut first = RequestGrouper::new(false).with_explicit_emission(Emission::Hold);
first.place(Begin);
let open = first.finish_fragment().open.expect("open");
assert_eq!(open.transaction().emission, Emission::Hold);
let mut second = RequestGrouper::resume(false, open);
let emissions: Vec<_> =
[Run, Commit, Begin, Run].iter().map(|kind| second.place(*kind).emission).collect();
assert_eq!(emissions, vec![Emission::Hold; 4]);
}
#[test]
fn a_nested_begin_in_a_resumed_block_is_marked() {
let mut first = RequestGrouper::new(false);
first.place(Begin);
let open = first.finish_fragment().open.expect("open");
let mut second = RequestGrouper::resume(false, open);
assert_eq!(second.place(Begin).role, NESTED);
let txns = second.finish();
assert_eq!(txns[0].aborted_at, Some(1));
assert_eq!(txns[0].misplaced, vec![(1, MisplacedControl::NestedBegin)]);
}
#[test]
fn a_split_request_folds_to_the_grouping_of_the_whole_request() {
let sequences: [&[RequestStatementKind]; 6] = [
&[Run, Begin, Run, Commit, Run],
&[Begin, Run, Cancel, Begin, Run, Commit],
&[Begin, Begin, Run, Begin, Commit, Cancel],
&[Commit, Begin, RequestStatementKind::Option, Run, Cancel, Run],
&[Begin, Run, Run],
&[Run, Begin, Run, Begin, Commit, Commit, Begin, Run],
];
for kinds in sequences {
let whole = lower_request(kinds, false);
let places = whole_places(kinds);
for mask in 0u32..(1 << (kinds.len() - 1)) {
let cuts: Vec<usize> = (0..kinds.len() - 1)
.filter(|bit| mask >> bit & 1 == 1)
.map(|bit| bit + 1)
.collect();
let (folded_places, folded, spanned) = fold_fragments(kinds, &cuts);
assert_eq!(folded_places, places, "{kinds:?} cut at {cuts:?}");
assert_eq!(folded, whole, "{kinds:?} cut at {cuts:?} (spanned: {spanned})");
}
}
}
#[test]
fn a_cut_inside_a_block_continues_it_and_a_cut_between_blocks_does_not() {
let kinds = [Run, Begin, Run, Commit, Run];
let (_, inside, spanned) = fold_fragments(&kinds, &[3]);
assert!(spanned);
assert_eq!(inside, lower_request(&kinds, false));
let (_, between, spanned) = fold_fragments(&kinds, &[1, 4]);
assert!(!spanned);
assert_eq!(between, lower_request(&kinds, false));
}
#[test]
fn a_session_grouper_never_returns_an_open_block() {
for kinds in [&[Begin, Run][..], &[Run, Begin, Commit, Cancel], &[Begin]] {
let mut grouper = RequestGrouper::new(true);
for kind in kinds {
grouper.place(*kind);
}
let fragment = grouper.finish_fragment();
assert!(fragment.open.is_none());
assert_eq!(fragment.transactions.len(), 1);
assert_eq!(fragment.transactions[0].mode, TxnMode::Session);
assert_eq!(fragment.transactions[0].start(), BlockStart::Begin);
}
let mut first = RequestGrouper::new(false);
first.place(Begin);
let open = first.finish_fragment().open.expect("open");
let mut session = RequestGrouper::resume(true, open);
assert_eq!(
session.place(Begin).role,
StatementRole::Misplaced(MisplacedControl::BeginInSession)
);
let fragment = session.finish_fragment();
assert!(fragment.open.is_none());
assert_eq!(fragment.transactions[0].statements, vec![1]);
}
#[test]
fn finish_still_leaves_an_open_block_unterminated() {
let kinds = [Begin, Run];
let mut grouper = RequestGrouper::new(false);
for kind in kinds {
grouper.place(kind);
}
let txns = grouper.finish();
assert_eq!(txns, lower_request(&kinds, false));
assert_eq!(txns[0].mode, explicit(TxnEnd::Unterminated));
assert_eq!(txns[0].start(), BlockStart::Begin);
}
}