1use 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#[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#[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
49static PARSED_TYPE_NAMES: LazyLock<RwLock<HashMap<Box<str>, Option<ParsedRegtypeName>>>> =
51 LazyLock::new(|| RwLock::new(HashMap::new()));
52const RETAINED_TYPE_NAMES: usize = 4096;
53
54pub 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
115pub 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 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 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 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 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 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
588pub(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;