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