uqa_execution/catalog/sequence/
definition.rs1use super::SequenceState;
9use uqa_sql::ast::{SequenceBound, SequenceDataType, SequenceRestart};
10use uqa_sql::schema::sequences::definition::{
11 altered_sequence_definition, validate_sequence_definition, SequenceDefinition,
12};
13use uqa_sql::SQLError;
14
15impl SequenceState {
16 #[must_use]
17 pub fn definition(&self) -> SequenceDefinition {
18 SequenceDefinition {
19 start: self.start,
20 increment: self.increment,
21 data_type: self.data_type,
22 min_value: self.min_value,
23 max_value: self.max_value,
24 cycle: self.cycle,
25 cache_size: self.cache_size,
26 }
27 }
28
29 #[must_use]
30 pub fn from_definition(definition: SequenceDefinition) -> Self {
31 Self {
32 start: definition.start,
33 increment: definition.increment,
34 data_type: definition.data_type,
35 min_value: definition.min_value,
36 max_value: definition.max_value,
37 cycle: definition.cycle,
38 cache_size: definition.cache_size,
39 current: definition.start,
40 called: false,
41 log_count: 0,
42 definition_generation: [0; 16],
43 owner: None,
44 }
45 }
46
47 #[must_use]
48 pub fn initial(start: i64, increment: i64, data_type: SequenceDataType) -> Self {
49 Self::from_definition(SequenceDefinition::initial(start, increment, data_type))
50 }
51
52 fn with_definition(mut self, definition: SequenceDefinition) -> Self {
53 self.start = definition.start;
54 self.increment = definition.increment;
55 self.data_type = definition.data_type;
56 self.min_value = definition.min_value;
57 self.max_value = definition.max_value;
58 self.cycle = definition.cycle;
59 self.cache_size = definition.cache_size;
60 self
61 }
62}
63
64pub fn altered_sequence_state(
65 mut state: SequenceState,
66 alter: &uqa_sql::ast::AlterSequence,
67) -> Result<SequenceState, SQLError> {
68 let resets_log_count = alter.data_type.is_some()
69 || alter.increment.is_some()
70 || alter.min_value != SequenceBound::Unchanged
71 || alter.max_value != SequenceBound::Unchanged
72 || alter.cycle.is_some()
73 || alter.cache_size.is_some()
74 || alter.restart != SequenceRestart::Unchanged;
75 state = state.with_definition(altered_sequence_definition(state.definition(), alter));
76 if alter.restart != SequenceRestart::Unchanged {
77 let restart_val = match alter.restart {
78 SequenceRestart::Unchanged => unreachable!("restart action was checked above"),
79 SequenceRestart::FromStart => state.start,
80 SequenceRestart::With(value) => value,
81 };
82 state.current = restart_val;
83 state.called = false;
84 }
85 if resets_log_count {
86 state.log_count = 0;
87 }
88 validate_sequence_definition(&state.definition(), Some(state.current))?;
89 Ok(state)
90}