Skip to main content

uqa_execution/catalog/sequence/
definition.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Apply SQL declarations to mutable sequence allocation state.
8use 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}