Skip to main content

uqa_sql/compiler/
types.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Column type and foreign-key constraint lowering helpers.
8
9use std::collections::HashMap;
10use std::sync::{LazyLock, RwLock};
11
12use pg_query::protobuf::Node;
13use pg_query::NodeEnum;
14
15use crate::ast::{ColumnType, IntervalFields, RangeSubtype};
16use crate::error::{Result, SQLError};
17
18use super::tree::extract_string;
19
20mod declarations;
21mod object_names;
22pub(crate) use declarations::compile_retained_type_declaration;
23pub(crate) use declarations::compile_retained_type_reference;
24pub(super) use declarations::preserve_alter_type_declaration;
25pub use object_names::parse_regobject_name;
26pub(crate) use object_names::parse_regobject_name_with_control;
27
28/// Parser-normalized type identity used by `PostgreSQL`'s `regtype` and `regprocedure` input functions. Components retain the parser's distinction between aliases such as unquoted `integer` (normalized to `pg_catalog.int4`) and a quoted type named `"integer"`. Modifier values do not participate in OID lookup; their presence is retained for declaration validation.
29#[derive(Debug, Clone, PartialEq, Eq)]
30pub struct ParsedRegtypeName {
31    pub names: Vec<String>,
32    pub array_dimensions: usize,
33    pub has_type_modifiers: bool,
34}
35
36/// Parser-normalized routine name and optional exact input-type signature used by `PostgreSQL`'s `regproc` and `regprocedure` input functions.
37#[derive(Debug, Clone, PartialEq, Eq)]
38pub struct ParsedRegprocedureName {
39    pub names: Vec<String>,
40    pub argument_types: Option<Vec<ParsedRegtypeName>>,
41}
42
43const POSTGRES_FUNCTION_MAX_ARGUMENTS: usize = 100;
44
45fn scanner_isspace(byte: u8) -> bool {
46    matches!(byte, b' ' | b'\t' | b'\n' | b'\r' | 0x0b | 0x0c)
47}
48
49/// A parsed type name is a function of its spelling alone, so each distinct spelling is parsed once per process. Reaching the bound discards the retained spellings instead of growing.
50static PARSED_TYPE_NAMES: LazyLock<RwLock<HashMap<Box<str>, Option<ParsedRegtypeName>>>> =
51    LazyLock::new(|| RwLock::new(HashMap::new()));
52const RETAINED_TYPE_NAMES: usize = 4096;
53
54/// Parse exactly one `PostgreSQL` type-name string without accepting adjacent SQL expressions. `None` is the soft-failure shape used for inputs such as an empty string or `SETOF integer`; lexical and type-name syntax errors are retained for the caller.
55pub fn parse_regtype_name(input: &str) -> Result<Option<ParsedRegtypeName>> {
56    let retained = PARSED_TYPE_NAMES
57        .read()
58        .ok()
59        .and_then(|names| names.get(input).cloned());
60    if let Some(parsed) = retained {
61        return Ok(parsed);
62    }
63    let parsed = parse_regtype_name_text(input)?;
64    if let Ok(mut names) = PARSED_TYPE_NAMES.write() {
65        if names.len() >= RETAINED_TYPE_NAMES {
66            names.clear();
67        }
68        names.insert(input.into(), parsed.clone());
69    }
70    Ok(parsed)
71}
72
73fn parse_regtype_name_text(input: &str) -> Result<Option<ParsedRegtypeName>> {
74    if input.bytes().all(scanner_isspace) {
75        return Ok(None);
76    }
77    let parsed = crate::parser::parse_with_mode(input, pg_query::ParseMode::TypeName)?;
78    let [raw] = parsed.protobuf.stmts.as_slice() else {
79        return Ok(None);
80    };
81    let Some(NodeEnum::List(names)) = raw.stmt.as_ref().and_then(|node| node.node.as_ref()) else {
82        return Ok(None);
83    };
84    let names = names
85        .items
86        .iter()
87        .map(extract_string)
88        .collect::<Result<Vec<_>>>()?;
89    if names.is_empty() {
90        return Ok(None);
91    }
92    let scanned = crate::parser::scan(input)?;
93    let tokens = scanned
94        .tokens
95        .iter()
96        .filter_map(|token| pg_query::protobuf::Token::try_from(token.token).ok())
97        .collect::<Vec<_>>();
98    if tokens.contains(&pg_query::protobuf::Token::Setof) {
99        return Ok(None);
100    }
101    let bracket_dimensions = tokens
102        .iter()
103        .filter(|token| **token == pg_query::protobuf::Token::Ascii91)
104        .count();
105    let array_dimensions = bracket_dimensions.max(usize::from(
106        tokens.contains(&pg_query::protobuf::Token::Array),
107    ));
108    Ok(Some(ParsedRegtypeName {
109        names,
110        array_dimensions,
111        has_type_modifiers: tokens.contains(&pg_query::protobuf::Token::Ascii40),
112    }))
113}
114
115/// Parse one routine-name string with either an omitted signature (`regproc`) or an exact signature (`regprocedure`). The caller owns the soft-error and cross-database policy because the two SQL input functions intentionally differ from ordinary DDL.
116pub fn parse_regprocedure_name(input: &str) -> Result<Option<ParsedRegprocedureName>> {
117    let mut in_quote = false;
118    let left_parenthesis = input.bytes().enumerate().find_map(|(offset, byte)| {
119        if byte == b'"' {
120            in_quote = !in_quote;
121            None
122        } else if byte == b'(' && !in_quote {
123            Some(offset)
124        } else {
125            None
126        }
127    });
128    let Some(left_parenthesis) = left_parenthesis else {
129        return parse_regobject_name(input)
130            .map(|names| {
131                Some(ParsedRegprocedureName {
132                    names,
133                    argument_types: None,
134                })
135            })
136            .ok_or_else(|| regprocedure_syntax_error("expected a left parenthesis".into()));
137    };
138    let Some(names) = parse_regobject_name(&input[..left_parenthesis]) else {
139        return Ok(None);
140    };
141
142    let bytes = input.as_bytes();
143    let mut end = bytes.len();
144    while end > left_parenthesis + 1 && scanner_isspace(bytes[end - 1]) {
145        end -= 1;
146    }
147    if end <= left_parenthesis + 1 || bytes[end - 1] != b')' {
148        return Err(regprocedure_syntax_error(format!(
149            "expected a right parenthesis in routine identity \"{input}\""
150        )));
151    }
152    let arguments = &input[left_parenthesis + 1..end - 1];
153    let argument_types = parse_regprocedure_argument_types(input, arguments)?;
154
155    Ok(Some(ParsedRegprocedureName {
156        names,
157        argument_types: Some(argument_types),
158    }))
159}
160
161fn parse_regprocedure_argument_types(
162    input: &str,
163    arguments: &str,
164) -> Result<Vec<ParsedRegtypeName>> {
165    let argument_bytes = arguments.as_bytes();
166    let mut argument_types = Vec::new();
167    let mut offset = 0usize;
168    let mut had_comma = false;
169    loop {
170        while argument_bytes
171            .get(offset)
172            .is_some_and(|byte| scanner_isspace(*byte))
173        {
174            offset += 1;
175        }
176        if offset == argument_bytes.len() {
177            if had_comma {
178                return Err(regprocedure_syntax_error(format!(
179                    "expected a type name in routine identity \"{input}\""
180                )));
181            }
182            break;
183        }
184
185        let start = offset;
186        let mut quoted = false;
187        let mut nesting = 0i32;
188        while let Some(byte) = argument_bytes.get(offset).copied() {
189            if byte == b'"' {
190                quoted = !quoted;
191            } else if byte == b',' && !quoted && nesting == 0 {
192                break;
193            } else if !quoted {
194                match byte {
195                    b'(' | b'[' => nesting += 1,
196                    b')' | b']' => nesting -= 1,
197                    _ => {}
198                }
199            }
200            offset += 1;
201        }
202        if quoted || nesting != 0 {
203            return Err(regprocedure_syntax_error(format!(
204                "improper type name in routine identity \"{input}\""
205            )));
206        }
207        let mut type_end = offset;
208        while type_end > start && scanner_isspace(argument_bytes[type_end - 1]) {
209            type_end -= 1;
210        }
211        let Some(type_name) = parse_regtype_name(&arguments[start..type_end])? else {
212            return Err(SQLError::Parse(format!(
213                "invalid type name in routine identity \"{input}\""
214            )));
215        };
216        if argument_types.len() == POSTGRES_FUNCTION_MAX_ARGUMENTS {
217            return Err(SQLError::Routine {
218                sqlstate: "54023".into(),
219                message: format!("too many arguments in routine identity \"{input}\""),
220            });
221        }
222        argument_types.push(type_name);
223        had_comma = argument_bytes.get(offset) == Some(&b',');
224        if had_comma {
225            offset += 1;
226        }
227    }
228
229    Ok(argument_types)
230}
231
232fn regprocedure_syntax_error(message: String) -> SQLError {
233    SQLError::Routine {
234        sqlstate: "22P02".into(),
235        message,
236    }
237}
238
239pub(super) fn compile_foreign_key_action(raw: &str) -> Result<crate::ast::ForeignKeyAction> {
240    use crate::ast::ForeignKeyAction;
241    match raw.as_bytes().first().copied() {
242        None | Some(0) | Some(b'a') => Ok(ForeignKeyAction::NoAction),
243        Some(b'r') => Ok(ForeignKeyAction::Restrict),
244        Some(b'c') => Ok(ForeignKeyAction::Cascade),
245        Some(b'n') => Ok(ForeignKeyAction::SetNull),
246        Some(b'd') => Ok(ForeignKeyAction::SetDefault),
247        Some(other) => Err(SQLError::Unsupported(format!(
248            "unsupported FOREIGN KEY action byte {other:?}"
249        ))),
250    }
251}
252
253pub(super) fn compile_foreign_key_match(raw: &str) -> Result<crate::ast::ForeignKeyMatch> {
254    use crate::ast::ForeignKeyMatch;
255    match raw.as_bytes().first().copied() {
256        None | Some(0) | Some(b's') => Ok(ForeignKeyMatch::Simple),
257        Some(b'f') => Ok(ForeignKeyMatch::Full),
258        Some(b'p') => Err(SQLError::Unsupported(
259            "FOREIGN KEY MATCH PARTIAL is not implemented by PostgreSQL".into(),
260        )),
261        Some(other) => Err(SQLError::Unsupported(format!(
262            "unsupported FOREIGN KEY match byte {other:?}"
263        ))),
264    }
265}
266
267pub(super) fn validate_foreign_key_set_columns(
268    local_columns: &[String],
269    set_columns: &[String],
270    raw_delete_action: &str,
271) -> Result<()> {
272    if set_columns.is_empty() {
273        return Ok(());
274    }
275    let action = compile_foreign_key_action(raw_delete_action)?;
276    if !matches!(
277        action,
278        crate::ast::ForeignKeyAction::SetNull | crate::ast::ForeignKeyAction::SetDefault
279    ) {
280        return Err(SQLError::Unsupported(
281            "FOREIGN KEY column lists are only valid for ON DELETE SET NULL/DEFAULT".into(),
282        ));
283    }
284    for col in set_columns {
285        if !local_columns.iter().any(|local| local == col) {
286            return Err(SQLError::Unsupported(format!(
287                "FOREIGN KEY SET column `{col}` is not part of the local key"
288            )));
289        }
290    }
291    Ok(())
292}
293
294pub(super) fn raw_type_name(col: &pg_query::protobuf::ColumnDef) -> Result<Option<String>> {
295    let Some(type_name) = col.type_name.as_ref() else {
296        return Ok(None);
297    };
298    let names = type_name
299        .names
300        .iter()
301        .map(extract_string)
302        .collect::<Result<Vec<_>>>()?;
303    Ok(names.last().map(|name| name.to_lowercase()))
304}
305
306pub(super) fn compile_type_name(col: &pg_query::protobuf::ColumnDef) -> Result<ColumnType> {
307    let Some(type_name) = col.type_name.as_ref() else {
308        return Err(SQLError::Internal(format!(
309            "column `{}` has no type",
310            col.colname
311        )));
312    };
313    compile_pg_type_name(type_name, &col.colname)
314}
315
316#[expect(
317    clippy::too_many_lines,
318    reason = "ordered PostgreSQL lowering preserves syntax and error precedence"
319)]
320pub(super) fn compile_pg_type_name(
321    type_name: &pg_query::protobuf::TypeName,
322    column_name: &str,
323) -> Result<ColumnType> {
324    let names = type_name
325        .names
326        .iter()
327        .map(extract_string)
328        .collect::<Result<Vec<_>>>()?;
329    let raw = names
330        .last()
331        .ok_or_else(|| {
332            SQLError::Internal(format!(
333                "type name for `{column_name}` has no name components"
334            ))
335        })?
336        .to_lowercase();
337    let bind_named = names
338        .first()
339        .is_some_and(|schema| names.len() > 1 && schema != "pg_catalog")
340        || names.last().is_some_and(|name| *name != raw)
341        || matches!(raw.as_str(), "integer" | "smallint" | "bigint" | "boolean");
342    let base = if bind_named {
343        compile_named_type(&names, type_name)
344    } else {
345        match raw.as_str() {
346            "smallint" | "int2" | "smallserial" | "serial2" => Ok(ColumnType::SmallInteger),
347            "int" | "int4" | "integer" | "serial" | "serial4" => Ok(ColumnType::Integer),
348            "bigint" | "int8" | "bigserial" | "serial8" => Ok(ColumnType::BigInteger),
349            "oid" => Ok(ColumnType::Oid),
350            "xid" => Ok(ColumnType::Xid),
351            "void" => Ok(ColumnType::Void),
352            "text" => Ok(ColumnType::Text),
353            "refcursor" => Ok(ColumnType::RefCursor),
354            "name" => Ok(ColumnType::Name),
355            "uuid" => Ok(ColumnType::Uuid),
356            "bit" | "varbit" => {
357                use crate::expr::bit_string::BitStringKind;
358                let kind = if raw == "bit" {
359                    BitStringKind::Fixed
360                } else {
361                    BitStringKind::Varying
362                };
363                if type_name.typmods.len() > 1 {
364                    return Err(SQLError::Routine {
365                        sqlstate: "22023".into(),
366                        message: "invalid type modifier".into(),
367                    });
368                }
369                let length = type_name
370                    .typmods
371                    .first()
372                    .map(|node| kind.validate_length(expect_integer_const(node)?))
373                    .transpose()?;
374                // The BIT keyword supplies length one in the parser; quoted/catalog bit retains the absent modifier.
375                Ok(if raw == "bit" {
376                    ColumnType::Bit(length)
377                } else {
378                    ColumnType::VarBit(length)
379                })
380            }
381            "varchar" | "character varying" => {
382                if type_name.typmods.len() > 1 {
383                    return Err(SQLError::TypeMismatch(format!(
384                        "CHARACTER VARYING accepts at most one length modifier, got {}",
385                        type_name.typmods.len()
386                    )));
387                }
388                let length = type_name
389                    .typmods
390                    .first()
391                    .map(|node| expect_positive_character_length(node, "varchar"))
392                    .transpose()?;
393                Ok(ColumnType::Varchar(length))
394            }
395            "char" => Ok(ColumnType::InternalChar),
396            "character" | "bpchar" => {
397                if type_name.typmods.len() > 1 {
398                    return Err(SQLError::TypeMismatch(format!(
399                        "CHARACTER accepts at most one length modifier, got {}",
400                        type_name.typmods.len()
401                    )));
402                }
403                let length = type_name
404                    .typmods
405                    .first()
406                    .map(|node| expect_positive_character_length(node, "bpchar"))
407                    .transpose()?;
408                // The parser supplies length one for CHAR/CHARACTER; the catalog name without a modifier is unconstrained.
409                Ok(match length {
410                    Some(length) => ColumnType::Character(length),
411                    None if raw == "bpchar" => ColumnType::Bpchar,
412                    None => ColumnType::Character(1),
413                })
414            }
415            "bool" | "boolean" => Ok(ColumnType::Boolean),
416            "real" | "float4" => Ok(ColumnType::Real),
417            "float8" | "double" | "double precision" => Ok(ColumnType::DoublePrecision),
418            "numeric" | "decimal" => {
419                if type_name.typmods.len() > 2 {
420                    return Err(SQLError::Routine {
421                        sqlstate: "22023".into(),
422                        message: "invalid NUMERIC type modifier".into(),
423                    });
424                }
425                let mut typmods_iter = type_name.typmods.iter();
426                let precision = typmods_iter
427                    .next()
428                    .map(|n| {
429                        let value = expect_integer_const(n)?;
430                        if !(1..=1000).contains(&value) {
431                            return Err(SQLError::Routine {
432                                sqlstate: "22023".into(),
433                                message: format!(
434                                    "NUMERIC precision {value} must be between 1 and 1000"
435                                ),
436                            });
437                        }
438                        Ok(value as u32)
439                    })
440                    .transpose()?;
441                let scale = typmods_iter
442                    .next()
443                    .map(|n| {
444                        let value = expect_integer_const(n)?;
445                        if !(-1000..=1000).contains(&value) {
446                            return Err(SQLError::Routine {
447                                sqlstate: "22023".into(),
448                                message: format!(
449                                    "NUMERIC scale {value} must be between -1000 and 1000"
450                                ),
451                            });
452                        }
453                        Ok(value as i32)
454                    })
455                    .transpose()?;
456                // PostgreSQL semantics: NUMERIC(precision) without an
457                // explicit scale defaults to scale=0, rounding to integers.
458                let scale = scale.or(precision.map(|_| 0));
459                Ok(ColumnType::Numeric { precision, scale })
460            }
461            "date" => Ok(ColumnType::Date),
462            "time" | "time without time zone" => Ok(ColumnType::Time),
463            "timetz" | "time with time zone" => Ok(ColumnType::TimeTz),
464            "timestamp" | "datetime" | "timestamp without time zone" => Ok(ColumnType::Timestamp),
465            "timestamptz" | "timestamp with time zone" => Ok(ColumnType::TimestampTz),
466            "interval" => {
467                let fields = type_name
468                    .typmods
469                    .first()
470                    .map(expect_integer_const)
471                    .transpose()?
472                    .unwrap_or(32767);
473                let fields = IntervalFields::from_modifier_mask(fields)
474                    .ok_or_else(|| SQLError::TypeMismatch("invalid interval fields".into()))?;
475                let precision = type_name
476                    .typmods
477                    .get(1)
478                    .map(expect_integer_const)
479                    .transpose()?;
480                ColumnType::with_interval_modifiers(fields, precision)
481            }
482            "int4range" => Ok(ColumnType::Range(RangeSubtype::Integer)),
483            "int8range" => Ok(ColumnType::Range(RangeSubtype::BigInteger)),
484            "numrange" => Ok(ColumnType::Range(RangeSubtype::Numeric)),
485            "daterange" => Ok(ColumnType::Range(RangeSubtype::Date)),
486            "tsrange" => Ok(ColumnType::Range(RangeSubtype::Timestamp)),
487            "tstzrange" => Ok(ColumnType::Range(RangeSubtype::TimestampTz)),
488            "int4multirange" => Ok(ColumnType::Multirange(RangeSubtype::Integer)),
489            "int8multirange" => Ok(ColumnType::Multirange(RangeSubtype::BigInteger)),
490            "nummultirange" => Ok(ColumnType::Multirange(RangeSubtype::Numeric)),
491            "datemultirange" => Ok(ColumnType::Multirange(RangeSubtype::Date)),
492            "tsmultirange" => Ok(ColumnType::Multirange(RangeSubtype::Timestamp)),
493            "tstzmultirange" => Ok(ColumnType::Multirange(RangeSubtype::TimestampTz)),
494            "json" => Ok(ColumnType::Json),
495            "jsonb" => Ok(ColumnType::JsonB),
496            "bytea" => Ok(ColumnType::Bytea),
497            "regproc" => Ok(ColumnType::Regproc),
498            "regprocedure" => Ok(ColumnType::Regprocedure),
499            "regclass" => Ok(ColumnType::Regclass),
500            "regcollation" => Ok(ColumnType::Regcollation),
501            "regnamespace" => Ok(ColumnType::Regnamespace),
502            "regrole" => Ok(ColumnType::Regrole),
503            "regtype" => Ok(ColumnType::Regtype),
504            "pg_node_tree" => Ok(ColumnType::PgNodeTree),
505            "aclitem" => Ok(ColumnType::AclItem),
506            "int2vector" => Ok(ColumnType::Int2Vector),
507            "oidvector" => Ok(ColumnType::OidVector),
508            "anyarray" => Ok(ColumnType::AnyArray),
509            "record" => Ok(ColumnType::Record),
510            "vector" => {
511                // VECTOR(N): the dimension is the only typmod argument.
512                let [arg] = type_name.typmods.as_slice() else {
513                    return Err(SQLError::Unsupported(
514                        "VECTOR requires exactly one dimension".into(),
515                    ));
516                };
517                let raw_dim = expect_integer_const(arg)?;
518                let dim = u32::try_from(raw_dim).map_err(|_| {
519                    SQLError::TypeMismatch(format!(
520                        "VECTOR dimension must be between 1 and {}, got {raw_dim}",
521                        u32::MAX
522                    ))
523                })?;
524                if dim == 0 {
525                    return Err(SQLError::TypeMismatch(
526                        "VECTOR dimension must be greater than zero".into(),
527                    ));
528                }
529                Ok(ColumnType::Vector(dim))
530            }
531            "tensor" => {
532                // TENSOR(N): an array of N-dimensional vectors.
533                let [arg] = type_name.typmods.as_slice() else {
534                    return Err(SQLError::Unsupported(
535                        "TENSOR requires exactly one dimension".into(),
536                    ));
537                };
538                let raw_dim = expect_integer_const(arg)?;
539                let dim = u32::try_from(raw_dim).map_err(|_| {
540                    SQLError::TypeMismatch(format!(
541                        "TENSOR dimension must be between 1 and {}, got {raw_dim}",
542                        u32::MAX
543                    ))
544                })?;
545                if dim == 0 {
546                    return Err(SQLError::TypeMismatch(
547                        "TENSOR dimension must be greater than zero".into(),
548                    ));
549                }
550                Ok(ColumnType::Tensor(dim))
551            }
552            _ => compile_named_type(&names, type_name),
553        }
554    }?;
555    let base = if matches!(
556        base,
557        ColumnType::Time | ColumnType::TimeTz | ColumnType::Timestamp | ColumnType::TimestampTz
558    ) {
559        if type_name.typmods.len() > 1 {
560            return Err(SQLError::TypeMismatch(
561                "invalid temporal type modifier".into(),
562            ));
563        }
564        base.with_temporal_precision(
565            type_name
566                .typmods
567                .first()
568                .map(expect_integer_const)
569                .transpose()?,
570        )?
571    } else {
572        base
573    };
574    if matches!(base, ColumnType::Void | ColumnType::PgNodeTree)
575        && !type_name.array_bounds.is_empty()
576    {
577        return Err(SQLError::Routine {
578            sqlstate: "42704".into(),
579            message: format!("type \"{}[]\" does not exist", base.sql_name()),
580        });
581    }
582    Ok(type_name
583        .array_bounds
584        .iter()
585        .fold(base, |element, _| ColumnType::Array(Box::new(element))))
586}
587
588/// Resolve a type reference without interpreting column-only serial pseudo-types.
589pub(super) fn compile_pg_type_reference(
590    type_name: &pg_query::protobuf::TypeName,
591    context: &str,
592) -> Result<ColumnType> {
593    let names = type_name
594        .names
595        .iter()
596        .map(extract_string)
597        .collect::<Result<Vec<_>>>()?;
598    if names.last().is_some_and(|name| {
599        matches!(
600            name.as_str(),
601            "serial" | "serial2" | "serial4" | "serial8" | "smallserial" | "bigserial"
602        )
603    }) {
604        let base = compile_named_type(&names, type_name)?;
605        return Ok(type_name
606            .array_bounds
607            .iter()
608            .fold(base, |element, _| ColumnType::Array(Box::new(element))));
609    }
610    compile_pg_type_name(type_name, context)
611}
612
613fn compile_named_type(
614    names: &[String],
615    type_name: &pg_query::protobuf::TypeName,
616) -> Result<ColumnType> {
617    let mut name = names
618        .iter()
619        .map(|name| format!("\"{}\"", name.replace('"', "\"\"")))
620        .collect::<Vec<_>>()
621        .join(".");
622    if !type_name.typmods.is_empty() {
623        let modifiers = type_name
624            .typmods
625            .iter()
626            .map(expect_integer_const)
627            .collect::<Result<Vec<_>>>()?;
628        name.push('(');
629        name.push_str(
630            &modifiers
631                .iter()
632                .map(ToString::to_string)
633                .collect::<Vec<_>>()
634                .join(","),
635        );
636        name.push(')');
637    }
638    Ok(ColumnType::Named(name))
639}
640
641fn expect_positive_character_length(node: &Node, type_name: &str) -> Result<u32> {
642    let length = expect_integer_const(node)?;
643    u32::try_from(length)
644        .ok()
645        .filter(|length| *length > 0)
646        .ok_or_else(|| SQLError::Routine {
647            sqlstate: "22023".into(),
648            message: format!("length for type {type_name} must be at least 1"),
649        })
650}
651
652fn expect_integer_const(node: &Node) -> Result<i64> {
653    let Some(inner) = node.node.as_ref() else {
654        return Err(SQLError::Internal("missing const node".into()));
655    };
656    match inner {
657        NodeEnum::AConst(c) => match &c.val {
658            Some(pg_query::protobuf::a_const::Val::Ival(i)) => Ok(i64::from(i.ival)),
659            Some(pg_query::protobuf::a_const::Val::Fval(f)) => {
660                f.fval.parse::<i64>().map_err(|_| {
661                    SQLError::TypeMismatch(format!(
662                        "type modifier must be an integer, got `{}`",
663                        f.fval
664                    ))
665                })
666            }
667            other => Err(SQLError::Internal(format!(
668                "expected integer constant, got {other:?}"
669            ))),
670        },
671        _ => Err(SQLError::Internal(format!(
672            "expected A_Const, got {inner:?}"
673        ))),
674    }
675}
676
677#[cfg(test)]
678mod tests;