pgmold 0.33.6

PostgreSQL schema-as-code management tool
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

use crate::model::*;
use crate::util::Result;
use sqlparser::ast::{DataType, Expr, ObjectName, SequenceOptions, UnaryOperator, Value};

use super::util::unquote_ident;

pub(super) fn parse_create_sequence(
    schema: &str,
    name: &str,
    data_type: Option<&DataType>,
    sequence_options: &[SequenceOptions],
    owned_by: Option<&ObjectName>,
) -> Result<Sequence> {
    let seq_data_type = data_type
        .map(|dt| match dt {
            DataType::SmallInt(_) => SequenceDataType::SmallInt,
            DataType::BigInt(_) => SequenceDataType::BigInt,
            DataType::Integer(_) | DataType::Int(_) => SequenceDataType::Integer,
            _ => SequenceDataType::Integer,
        })
        .unwrap_or(SequenceDataType::Integer);

    let mut start: Option<i64> = None;
    let mut increment: Option<i64> = None;
    let mut min_value: Option<i64> = None;
    let mut max_value: Option<i64> = None;
    let mut cycle = false;
    let mut cache: Option<i64> = None;

    for option in sequence_options {
        match option {
            SequenceOptions::IncrementBy(expr, _) => {
                increment = extract_i64_from_expr(expr);
            }
            SequenceOptions::MinValue(Some(expr)) => {
                min_value = extract_i64_from_expr(expr);
            }
            SequenceOptions::MaxValue(Some(expr)) => {
                max_value = extract_i64_from_expr(expr);
            }
            SequenceOptions::StartWith(expr, _) => {
                start = extract_i64_from_expr(expr);
            }
            SequenceOptions::Cache(expr) => {
                cache = extract_i64_from_expr(expr);
            }
            SequenceOptions::Cycle(c) => {
                cycle = *c;
            }
            _ => {}
        }
    }

    let owned_by_parsed = owned_by.and_then(|obj_name| {
        let parts: Vec<String> = obj_name
            .0
            .iter()
            .map(|part| unquote_ident(&part.to_string()).to_string())
            .collect();
        match parts.as_slice() {
            [table_schema, table_name, column_name] => Some(SequenceOwner {
                table_schema: table_schema.clone(),
                table_name: table_name.clone(),
                column_name: column_name.clone(),
            }),
            [table_name, column_name] => Some(SequenceOwner {
                table_schema: "public".to_string(),
                table_name: table_name.clone(),
                column_name: column_name.clone(),
            }),
            _ => None,
        }
    });

    let increment = increment.or(Some(1));
    let is_ascending = increment.unwrap_or(1) > 0;
    let cache = cache.or(Some(1));

    let min_value = min_value.or(if is_ascending {
        Some(1)
    } else {
        match seq_data_type {
            SequenceDataType::SmallInt => Some(-32768),
            SequenceDataType::Integer => Some(-2147483648),
            SequenceDataType::BigInt => Some(-9223372036854775808),
        }
    });

    let max_value = max_value.or(if is_ascending {
        match seq_data_type {
            SequenceDataType::SmallInt => Some(32767),
            SequenceDataType::Integer => Some(2147483647),
            SequenceDataType::BigInt => Some(9223372036854775807),
        }
    } else {
        Some(-1)
    });

    let start = start.or(if is_ascending { min_value } else { max_value });

    Ok(Sequence {
        name: name.to_string(),
        schema: schema.to_string(),
        data_type: seq_data_type,
        start,
        increment,
        min_value,
        max_value,
        cycle,
        cache,
        owned_by: owned_by_parsed,
        owner: None,
        grants: Vec::new(),
        comment: None,
    })
}

fn extract_i64_from_expr(expr: &Expr) -> Option<i64> {
    match expr {
        Expr::Value(value_with_span) => {
            if let Value::Number(n, _) = &value_with_span.value {
                n.parse::<i64>().ok()
            } else {
                None
            }
        }
        Expr::UnaryOp { op, expr } => {
            if matches!(op, UnaryOperator::Minus) {
                extract_i64_from_expr(expr).map(|n| -n)
            } else {
                None
            }
        }
        _ => None,
    }
}