1use 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#[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#[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
46pub 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
89pub 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 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 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 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 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 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
562pub(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}