uqa-sql 0.5.2

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

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

//! The clauses of a column definition as `transformColumnDefinition` reads them, which the statement keeps until the relation is found.

use super::{NodeEnum, Result, SQLError};
use crate::ast::{ColumnClause, ColumnClauseKind, ColumnDeclaration};
use pg_query::protobuf::ConstrType;

/// The pseudo-types `transformColumnDefinition` treats as SERIAL: one unqualified name, without `%TYPE`.
const SERIAL_TYPES: [&str; 6] = [
    "smallserial",
    "serial2",
    "serial",
    "serial4",
    "bigserial",
    "serial8",
];

/// The SERIAL type and the clauses, in written order, of a column definition.
pub(in crate::compiler) fn compile_column_declaration(
    column: &pg_query::protobuf::ColumnDef,
) -> Result<ColumnDeclaration> {
    let serial = column.type_name.as_ref().is_some_and(|type_name| {
        !type_name.pct_type
            && matches!(
                type_name.names.as_slice(),
                [name] if matches!(
                    name.node.as_ref(),
                    Some(NodeEnum::String(name)) if SERIAL_TYPES.contains(&name.sval.as_str())
                )
            )
    });
    let serial_array = serial
        && column
            .type_name
            .as_ref()
            .is_some_and(|type_name| !type_name.array_bounds.is_empty());
    let clauses = column
        .constraints
        .iter()
        .map(|node| {
            let Some(NodeEnum::Constraint(constraint)) = node.node.as_ref() else {
                return Err(SQLError::Internal(format!(
                    "unexpected column constraint node {:?}",
                    node.node
                )));
            };
            Ok(ColumnClause {
                kind: clause_kind(constraint.contype())?,
                name: (!constraint.conname.is_empty()).then(|| constraint.conname.clone()),
                no_inherit: constraint.is_no_inherit,
            })
        })
        .collect::<Result<Vec<_>>>()?;
    Ok(ColumnDeclaration {
        serial,
        serial_array,
        clauses,
    })
}

fn clause_kind(kind: ConstrType) -> Result<ColumnClauseKind> {
    Ok(match kind {
        ConstrType::ConstrNull => ColumnClauseKind::Null,
        ConstrType::ConstrNotnull => ColumnClauseKind::NotNull,
        ConstrType::ConstrDefault => ColumnClauseKind::Default,
        ConstrType::ConstrIdentity => ColumnClauseKind::Identity,
        ConstrType::ConstrGenerated => ColumnClauseKind::Generated,
        ConstrType::ConstrCheck => ColumnClauseKind::Check,
        ConstrType::ConstrPrimary => ColumnClauseKind::PrimaryKey,
        ConstrType::ConstrUnique => ColumnClauseKind::Unique,
        ConstrType::ConstrForeign => ColumnClauseKind::ForeignKey,
        ConstrType::ConstrAttrDeferrable => ColumnClauseKind::Deferrable,
        ConstrType::ConstrAttrNotDeferrable => ColumnClauseKind::NotDeferrable,
        ConstrType::ConstrAttrDeferred => ColumnClauseKind::InitiallyDeferred,
        ConstrType::ConstrAttrImmediate => ColumnClauseKind::InitiallyImmediate,
        ConstrType::ConstrAttrEnforced => ColumnClauseKind::Enforced,
        ConstrType::ConstrAttrNotEnforced => ColumnClauseKind::NotEnforced,
        other => {
            return Err(SQLError::Unsupported(format!(
                "column constraint {other:?} is not supported"
            )))
        }
    })
}