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

uqa_sql/compiler/
types.rs
