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