uqa-sql 0.3.5

PostgreSQL-compatible SQL compiler built on libpg_query
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

//! Normalize and validate SQL sequence declarations independently of allocation state.
use crate::ast::{AlterSequence, CreateSequence, SequenceBound, SequenceDataType};
use crate::SQLError;

/// Fully specified SQL sequence options after defaults and ALTER actions are applied.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SequenceDefinition {
    pub start: i64,
    pub increment: i64,
    pub data_type: SequenceDataType,
    pub min_value: i64,
    pub max_value: i64,
    pub cycle: bool,
    pub cache_size: i64,
}

impl SequenceDefinition {
    #[must_use]
    pub fn initial(start: i64, increment: i64, data_type: SequenceDataType) -> Self {
        let (type_min, type_max) = data_type.bounds();
        Self {
            start,
            increment,
            data_type,
            min_value: if increment > 0 { 1 } else { type_min },
            max_value: if increment > 0 { type_max } else { -1 },
            cycle: false,
            cache_size: 1,
        }
    }

    #[must_use]
    pub fn from_create(sequence: &CreateSequence) -> Self {
        let mut definition = Self::initial(sequence.start, sequence.increment, sequence.data_type);
        definition.min_value = sequence.min_value.unwrap_or(definition.min_value);
        definition.max_value = sequence.max_value.unwrap_or(definition.max_value);
        definition.cycle = sequence.cycle;
        definition.cache_size = sequence.cache_size;
        definition
    }
}

#[must_use]
pub fn altered_sequence_definition(
    mut state: SequenceDefinition,
    alter: &AlterSequence,
) -> SequenceDefinition {
    if let Some(data_type) = alter.data_type {
        let (old_type_min, old_type_max) = state.data_type.bounds();
        let (new_type_min, new_type_max) = data_type.bounds();
        if state.min_value == old_type_min {
            state.min_value = new_type_min;
        }
        if state.max_value == old_type_max {
            state.max_value = new_type_max;
        }
        state.data_type = data_type;
    }
    if let Some(increment) = alter.increment {
        state.increment = increment;
    }
    let (type_min, type_max) = state.data_type.bounds();
    match alter.min_value {
        SequenceBound::Unchanged => {}
        SequenceBound::Default => {
            state.min_value = if state.increment > 0 { 1 } else { type_min };
        }
        SequenceBound::Value(value) => state.min_value = value,
    }
    match alter.max_value {
        SequenceBound::Unchanged => {}
        SequenceBound::Default => {
            state.max_value = if state.increment > 0 { type_max } else { -1 };
        }
        SequenceBound::Value(value) => state.max_value = value,
    }
    if let Some(start_val) = alter.start {
        state.start = start_val;
    }
    if let Some(cycle) = alter.cycle {
        state.cycle = cycle;
    }
    if let Some(cache_size) = alter.cache_size {
        state.cache_size = cache_size;
    }
    state
}

pub fn validate_sequence_definition(
    state: &SequenceDefinition,
    current: Option<i64>,
) -> Result<(), SQLError> {
    let validate_current = current.is_some();
    let current = current.unwrap_or_default();
    let invalid = |message| SQLError::Routine {
        sqlstate: "22023".into(),
        message,
    };
    if state.increment == 0 {
        return Err(invalid("INCREMENT must not be zero".into()));
    }
    if state.cache_size <= 0 {
        return Err(invalid(format!(
            "CACHE ({}) must be greater than zero",
            state.cache_size
        )));
    }
    let (type_min, type_max) = state.data_type.bounds();
    if !(type_min..=type_max).contains(&state.max_value) {
        return Err(invalid(format!(
            "MAXVALUE ({}) is out of range for sequence data type {}",
            state.max_value,
            state.data_type.sql_name()
        )));
    }
    if !(type_min..=type_max).contains(&state.min_value) {
        return Err(invalid(format!(
            "MINVALUE ({}) is out of range for sequence data type {}",
            state.min_value,
            state.data_type.sql_name()
        )));
    }
    if state.min_value >= state.max_value {
        return Err(invalid(format!(
            "MINVALUE ({}) must be less than MAXVALUE ({})",
            state.min_value, state.max_value
        )));
    }
    if state.start < state.min_value {
        return Err(invalid(format!(
            "START value ({}) cannot be less than MINVALUE ({})",
            state.start, state.min_value
        )));
    }
    if state.start > state.max_value {
        return Err(invalid(format!(
            "START value ({}) cannot be greater than MAXVALUE ({})",
            state.start, state.max_value
        )));
    }
    if validate_current && current < state.min_value {
        return Err(invalid(format!(
            "RESTART value ({}) cannot be less than MINVALUE ({})",
            current, state.min_value
        )));
    }
    if validate_current && current > state.max_value {
        return Err(invalid(format!(
            "RESTART value ({}) cannot be greater than MAXVALUE ({})",
            current, state.max_value
        )));
    }
    Ok(())
}