use std::collections::HashMap;
use std::sync::{LazyLock, RwLock};
use pg_query::protobuf::Node;
use pg_query::NodeEnum;
use crate::ast::{ColumnType, IntervalFields, RangeSubtype};
use crate::error::{Result, SQLError};
use uqa_core::memory::{Produced, ProductionControl, ProductionVec};
use super::tree::extract_string;
mod declarations;
mod object_names;
mod routine_names;
pub(crate) use declarations::compile_retained_type_declaration;
pub(crate) use declarations::compile_retained_type_reference;
pub(super) use declarations::preserve_alter_type_declaration;
pub use object_names::parse_regobject_name;
pub use object_names::parse_regobject_name_with_control;
pub use routine_names::parse_regprocedure_name_with_control;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ParsedRegtypeName {
pub names: Vec<String>,
pub array_dimensions: usize,
pub has_type_modifiers: bool,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ParsedRegprocedureName {
pub names: Vec<String>,
pub argument_types: Option<Vec<ParsedRegtypeName>>,
}
const POSTGRES_FUNCTION_MAX_ARGUMENTS: usize = 100;
fn scanner_isspace(byte: u8) -> bool {
matches!(byte, b' ' | b'\t' | b'\n' | b'\r' | 0x0b | 0x0c)
}
static PARSED_TYPE_NAMES: LazyLock<RwLock<HashMap<Box<str>, Option<ParsedRegtypeName>>>> =
LazyLock::new(|| RwLock::new(HashMap::new()));
const RETAINED_TYPE_NAMES: usize = 4096;
pub fn parse_regtype_name(input: &str) -> Result<Option<ParsedRegtypeName>> {
let retained = PARSED_TYPE_NAMES
.read()
.ok()
.and_then(|names| names.get(input).cloned());
if let Some(parsed) = retained {
return Ok(parsed);
}
let parsed = parse_regtype_name_text(input)?;
if let Ok(mut names) = PARSED_TYPE_NAMES.write() {
if names.len() >= RETAINED_TYPE_NAMES {
names.clear();
}
names.insert(input.into(), parsed.clone());
}
Ok(parsed)
}
fn parse_regtype_name_text(input: &str) -> Result<Option<ParsedRegtypeName>> {
parse_regtype_name_text_with_control(input, &ProductionControl::uncontrolled()).map(|parsed| {
parsed.map(|parsed| {
parsed
.into_uncontrolled()
.expect("ordinary type-name parsing")
})
})
}
pub fn parse_regtype_name_with_control(
input: &str,
control: &ProductionControl<'_>,
) -> Result<Option<Produced<ParsedRegtypeName>>> {
control.check()?;
if let Ok(names) = PARSED_TYPE_NAMES.read() {
if let Some(parsed) = names.get(input) {
return parsed
.as_ref()
.map(|parsed| {
let mut names = ProductionVec::new(*control);
names.reserve(parsed.names.len())?;
for name in &parsed.names {
names.push_produced(control.copy_text(name)?)?;
}
let (names, memory) = names.finish()?.into_parts();
Ok(control.finish(
ParsedRegtypeName {
names,
array_dimensions: parsed.array_dimensions,
has_type_modifiers: parsed.has_type_modifiers,
},
memory,
)?)
})
.transpose();
}
}
parse_regtype_name_text_with_control(input, control)
}
fn parse_regtype_name_text_with_control(
input: &str,
control: &ProductionControl<'_>,
) -> Result<Option<Produced<ParsedRegtypeName>>> {
control.check()?;
if input.bytes().all(scanner_isspace) {
return Ok(None);
}
let parsed = crate::parser::parse_with_mode(input, pg_query::ParseMode::TypeName)?;
let [raw] = parsed.protobuf.stmts.as_slice() else {
return Ok(None);
};
let Some(NodeEnum::List(names)) = raw.stmt.as_ref().and_then(|node| node.node.as_ref()) else {
return Ok(None);
};
let mut projected_names = ProductionVec::new(*control);
projected_names.reserve(names.items.len())?;
for name in &names.items {
let Some(NodeEnum::String(name)) = name.node.as_ref() else {
return Err(SQLError::Internal("expected type-name string node".into()));
};
projected_names.push_produced(control.copy_text(&name.sval)?)?;
}
if projected_names.is_empty() {
return Ok(None);
}
let scanned = crate::parser::scan(input)?;
let mut bracket_dimensions = 0;
let mut array = false;
let mut has_type_modifiers = false;
for token in &scanned.tokens {
control.check()?;
match pg_query::protobuf::Token::try_from(token.token).ok() {
Some(pg_query::protobuf::Token::Setof) => return Ok(None),
Some(pg_query::protobuf::Token::Ascii91) => bracket_dimensions += 1,
Some(pg_query::protobuf::Token::Array) => array = true,
Some(pg_query::protobuf::Token::Ascii40) => has_type_modifiers = true,
_ => {}
}
}
let array_dimensions = bracket_dimensions.max(usize::from(array));
let (names, memory) = projected_names.finish()?.into_parts();
Ok(Some(control.finish(
ParsedRegtypeName {
names,
array_dimensions,
has_type_modifiers,
},
memory,
)?))
}
pub fn parse_regprocedure_name(input: &str) -> Result<Option<ParsedRegprocedureName>> {
parse_regprocedure_name_with_control(input, &ProductionControl::uncontrolled()).map(|parsed| {
parsed.map(|parsed| {
parsed
.into_uncontrolled()
.expect("ordinary routine identity parsing")
})
})
}
pub(super) fn compile_foreign_key_action(raw: &str) -> Result<crate::ast::ForeignKeyAction> {
use crate::ast::ForeignKeyAction;
match raw.as_bytes().first().copied() {
None | Some(0) | Some(b'a') => Ok(ForeignKeyAction::NoAction),
Some(b'r') => Ok(ForeignKeyAction::Restrict),
Some(b'c') => Ok(ForeignKeyAction::Cascade),
Some(b'n') => Ok(ForeignKeyAction::SetNull),
Some(b'd') => Ok(ForeignKeyAction::SetDefault),
Some(other) => Err(SQLError::Unsupported(format!(
"unsupported FOREIGN KEY action byte {other:?}"
))),
}
}
pub(super) fn compile_foreign_key_match(raw: &str) -> Result<crate::ast::ForeignKeyMatch> {
use crate::ast::ForeignKeyMatch;
match raw.as_bytes().first().copied() {
None | Some(0) | Some(b's') => Ok(ForeignKeyMatch::Simple),
Some(b'f') => Ok(ForeignKeyMatch::Full),
Some(b'p') => Err(SQLError::Unsupported(
"FOREIGN KEY MATCH PARTIAL is not implemented by PostgreSQL".into(),
)),
Some(other) => Err(SQLError::Unsupported(format!(
"unsupported FOREIGN KEY match byte {other:?}"
))),
}
}
pub(super) fn validate_foreign_key_set_columns(
local_columns: &[String],
set_columns: &[String],
raw_delete_action: &str,
) -> Result<()> {
if set_columns.is_empty() {
return Ok(());
}
let action = compile_foreign_key_action(raw_delete_action)?;
if !matches!(
action,
crate::ast::ForeignKeyAction::SetNull | crate::ast::ForeignKeyAction::SetDefault
) {
return Err(SQLError::Unsupported(
"FOREIGN KEY column lists are only valid for ON DELETE SET NULL/DEFAULT".into(),
));
}
for col in set_columns {
if !local_columns.iter().any(|local| local == col) {
return Err(SQLError::Unsupported(format!(
"FOREIGN KEY SET column `{col}` is not part of the local key"
)));
}
}
Ok(())
}
pub(super) fn raw_type_name(col: &pg_query::protobuf::ColumnDef) -> Result<Option<String>> {
let Some(type_name) = col.type_name.as_ref() else {
return Ok(None);
};
let names = type_name
.names
.iter()
.map(extract_string)
.collect::<Result<Vec<_>>>()?;
Ok(names.last().map(|name| name.to_lowercase()))
}
pub(super) fn compile_type_name(col: &pg_query::protobuf::ColumnDef) -> Result<ColumnType> {
let Some(type_name) = col.type_name.as_ref() else {
return Err(SQLError::Internal(format!(
"column `{}` has no type",
col.colname
)));
};
compile_pg_type_name(type_name, &col.colname)
}
#[expect(
clippy::too_many_lines,
reason = "ordered PostgreSQL lowering preserves syntax and error precedence"
)]
pub(super) fn compile_pg_type_name(
type_name: &pg_query::protobuf::TypeName,
column_name: &str,
) -> Result<ColumnType> {
let names = type_name
.names
.iter()
.map(extract_string)
.collect::<Result<Vec<_>>>()?;
let raw = names
.last()
.ok_or_else(|| {
SQLError::Internal(format!(
"type name for `{column_name}` has no name components"
))
})?
.to_lowercase();
let bind_named = names
.first()
.is_some_and(|schema| names.len() > 1 && schema != "pg_catalog")
|| names.last().is_some_and(|name| *name != raw)
|| matches!(raw.as_str(), "integer" | "smallint" | "bigint" | "boolean");
let base = if bind_named {
compile_named_type(&names, type_name)
} else {
match raw.as_str() {
"smallint" | "int2" | "smallserial" | "serial2" => Ok(ColumnType::SmallInteger),
"int" | "int4" | "integer" | "serial" | "serial4" => Ok(ColumnType::Integer),
"bigint" | "int8" | "bigserial" | "serial8" => Ok(ColumnType::BigInteger),
"oid" => Ok(ColumnType::Oid),
"xid" => Ok(ColumnType::Xid),
"void" => Ok(ColumnType::Void),
"text" => Ok(ColumnType::Text),
"refcursor" => Ok(ColumnType::RefCursor),
"name" => Ok(ColumnType::Name),
"uuid" => Ok(ColumnType::Uuid),
"bit" | "varbit" => {
use crate::expr::bit_string::BitStringKind;
let kind = if raw == "bit" {
BitStringKind::Fixed
} else {
BitStringKind::Varying
};
if type_name.typmods.len() > 1 {
return Err(SQLError::Routine {
sqlstate: "22023".into(),
message: "invalid type modifier".into(),
});
}
let length = type_name
.typmods
.first()
.map(|node| kind.validate_length(expect_integer_const(node)?))
.transpose()?;
Ok(if raw == "bit" {
ColumnType::Bit(length)
} else {
ColumnType::VarBit(length)
})
}
"varchar" | "character varying" => {
if type_name.typmods.len() > 1 {
return Err(SQLError::TypeMismatch(format!(
"CHARACTER VARYING accepts at most one length modifier, got {}",
type_name.typmods.len()
)));
}
let length = type_name
.typmods
.first()
.map(|node| expect_positive_character_length(node, "varchar"))
.transpose()?;
Ok(ColumnType::Varchar(length))
}
"char" => Ok(ColumnType::InternalChar),
"character" | "bpchar" => {
if type_name.typmods.len() > 1 {
return Err(SQLError::TypeMismatch(format!(
"CHARACTER accepts at most one length modifier, got {}",
type_name.typmods.len()
)));
}
let length = type_name
.typmods
.first()
.map(|node| expect_positive_character_length(node, "bpchar"))
.transpose()?;
Ok(match length {
Some(length) => ColumnType::Character(length),
None if raw == "bpchar" => ColumnType::Bpchar,
None => ColumnType::Character(1),
})
}
"bool" | "boolean" => Ok(ColumnType::Boolean),
"real" | "float4" => Ok(ColumnType::Real),
"float8" | "double" | "double precision" => Ok(ColumnType::DoublePrecision),
"numeric" | "decimal" => {
if type_name.typmods.len() > 2 {
return Err(SQLError::Routine {
sqlstate: "22023".into(),
message: "invalid NUMERIC type modifier".into(),
});
}
let mut typmods_iter = type_name.typmods.iter();
let precision = typmods_iter
.next()
.map(|n| {
let value = expect_integer_const(n)?;
if !(1..=1000).contains(&value) {
return Err(SQLError::Routine {
sqlstate: "22023".into(),
message: format!(
"NUMERIC precision {value} must be between 1 and 1000"
),
});
}
Ok(value as u32)
})
.transpose()?;
let scale = typmods_iter
.next()
.map(|n| {
let value = expect_integer_const(n)?;
if !(-1000..=1000).contains(&value) {
return Err(SQLError::Routine {
sqlstate: "22023".into(),
message: format!(
"NUMERIC scale {value} must be between -1000 and 1000"
),
});
}
Ok(value as i32)
})
.transpose()?;
let scale = scale.or(precision.map(|_| 0));
Ok(ColumnType::Numeric { precision, scale })
}
"date" => Ok(ColumnType::Date),
"time" | "time without time zone" => Ok(ColumnType::Time),
"timetz" | "time with time zone" => Ok(ColumnType::TimeTz),
"timestamp" | "datetime" | "timestamp without time zone" => Ok(ColumnType::Timestamp),
"timestamptz" | "timestamp with time zone" => Ok(ColumnType::TimestampTz),
"interval" => {
let fields = type_name
.typmods
.first()
.map(expect_integer_const)
.transpose()?
.unwrap_or(32767);
let fields = IntervalFields::from_modifier_mask(fields)
.ok_or_else(|| SQLError::TypeMismatch("invalid interval fields".into()))?;
let precision = type_name
.typmods
.get(1)
.map(expect_integer_const)
.transpose()?;
ColumnType::with_interval_modifiers(fields, precision)
}
"int4range" => Ok(ColumnType::Range(RangeSubtype::Integer)),
"int8range" => Ok(ColumnType::Range(RangeSubtype::BigInteger)),
"numrange" => Ok(ColumnType::Range(RangeSubtype::Numeric)),
"daterange" => Ok(ColumnType::Range(RangeSubtype::Date)),
"tsrange" => Ok(ColumnType::Range(RangeSubtype::Timestamp)),
"tstzrange" => Ok(ColumnType::Range(RangeSubtype::TimestampTz)),
"int4multirange" => Ok(ColumnType::Multirange(RangeSubtype::Integer)),
"int8multirange" => Ok(ColumnType::Multirange(RangeSubtype::BigInteger)),
"nummultirange" => Ok(ColumnType::Multirange(RangeSubtype::Numeric)),
"datemultirange" => Ok(ColumnType::Multirange(RangeSubtype::Date)),
"tsmultirange" => Ok(ColumnType::Multirange(RangeSubtype::Timestamp)),
"tstzmultirange" => Ok(ColumnType::Multirange(RangeSubtype::TimestampTz)),
"json" => Ok(ColumnType::Json),
"jsonb" => Ok(ColumnType::JsonB),
"bytea" => Ok(ColumnType::Bytea),
"regproc" => Ok(ColumnType::Regproc),
"regprocedure" => Ok(ColumnType::Regprocedure),
"regclass" => Ok(ColumnType::Regclass),
"regcollation" => Ok(ColumnType::Regcollation),
"regnamespace" => Ok(ColumnType::Regnamespace),
"regrole" => Ok(ColumnType::Regrole),
"regtype" => Ok(ColumnType::Regtype),
"pg_node_tree" => Ok(ColumnType::PgNodeTree),
"aclitem" => Ok(ColumnType::AclItem),
"int2vector" => Ok(ColumnType::Int2Vector),
"oidvector" => Ok(ColumnType::OidVector),
"anyarray" => Ok(ColumnType::AnyArray),
"record" => Ok(ColumnType::Record),
"vector" => {
let [arg] = type_name.typmods.as_slice() else {
return Err(SQLError::Unsupported(
"VECTOR requires exactly one dimension".into(),
));
};
let raw_dim = expect_integer_const(arg)?;
let dim = u32::try_from(raw_dim).map_err(|_| {
SQLError::TypeMismatch(format!(
"VECTOR dimension must be between 1 and {}, got {raw_dim}",
u32::MAX
))
})?;
if dim == 0 {
return Err(SQLError::TypeMismatch(
"VECTOR dimension must be greater than zero".into(),
));
}
Ok(ColumnType::Vector(dim))
}
"tensor" => {
let [arg] = type_name.typmods.as_slice() else {
return Err(SQLError::Unsupported(
"TENSOR requires exactly one dimension".into(),
));
};
let raw_dim = expect_integer_const(arg)?;
let dim = u32::try_from(raw_dim).map_err(|_| {
SQLError::TypeMismatch(format!(
"TENSOR dimension must be between 1 and {}, got {raw_dim}",
u32::MAX
))
})?;
if dim == 0 {
return Err(SQLError::TypeMismatch(
"TENSOR dimension must be greater than zero".into(),
));
}
Ok(ColumnType::Tensor(dim))
}
_ => compile_named_type(&names, type_name),
}
}?;
let base = if matches!(
base,
ColumnType::Time | ColumnType::TimeTz | ColumnType::Timestamp | ColumnType::TimestampTz
) {
if type_name.typmods.len() > 1 {
return Err(SQLError::TypeMismatch(
"invalid temporal type modifier".into(),
));
}
base.with_temporal_precision(
type_name
.typmods
.first()
.map(expect_integer_const)
.transpose()?,
)?
} else {
base
};
if matches!(base, ColumnType::Void | ColumnType::PgNodeTree)
&& !type_name.array_bounds.is_empty()
{
return Err(SQLError::Routine {
sqlstate: "42704".into(),
message: format!("type \"{}[]\" does not exist", base.sql_name()),
});
}
Ok(type_name
.array_bounds
.iter()
.fold(base, |element, _| ColumnType::Array(Box::new(element))))
}
pub(super) fn compile_pg_type_reference(
type_name: &pg_query::protobuf::TypeName,
context: &str,
) -> Result<ColumnType> {
let names = type_name
.names
.iter()
.map(extract_string)
.collect::<Result<Vec<_>>>()?;
if names.last().is_some_and(|name| {
matches!(
name.as_str(),
"serial" | "serial2" | "serial4" | "serial8" | "smallserial" | "bigserial"
)
}) {
let base = compile_named_type(&names, type_name)?;
return Ok(type_name
.array_bounds
.iter()
.fold(base, |element, _| ColumnType::Array(Box::new(element))));
}
compile_pg_type_name(type_name, context)
}
fn compile_named_type(
names: &[String],
type_name: &pg_query::protobuf::TypeName,
) -> Result<ColumnType> {
let mut name = names
.iter()
.map(|name| format!("\"{}\"", name.replace('"', "\"\"")))
.collect::<Vec<_>>()
.join(".");
if !type_name.typmods.is_empty() {
let modifiers = type_name
.typmods
.iter()
.map(expect_integer_const)
.collect::<Result<Vec<_>>>()?;
name.push('(');
name.push_str(
&modifiers
.iter()
.map(ToString::to_string)
.collect::<Vec<_>>()
.join(","),
);
name.push(')');
}
Ok(ColumnType::Named(name))
}
fn expect_positive_character_length(node: &Node, type_name: &str) -> Result<u32> {
let length = expect_integer_const(node)?;
u32::try_from(length)
.ok()
.filter(|length| *length > 0)
.ok_or_else(|| SQLError::Routine {
sqlstate: "22023".into(),
message: format!("length for type {type_name} must be at least 1"),
})
}
fn expect_integer_const(node: &Node) -> Result<i64> {
let Some(inner) = node.node.as_ref() else {
return Err(SQLError::Internal("missing const node".into()));
};
match inner {
NodeEnum::AConst(c) => match &c.val {
Some(pg_query::protobuf::a_const::Val::Ival(i)) => Ok(i64::from(i.ival)),
Some(pg_query::protobuf::a_const::Val::Fval(f)) => {
f.fval.parse::<i64>().map_err(|_| {
SQLError::TypeMismatch(format!(
"type modifier must be an integer, got `{}`",
f.fval
))
})
}
other => Err(SQLError::Internal(format!(
"expected integer constant, got {other:?}"
))),
},
_ => Err(SQLError::Internal(format!(
"expected A_Const, got {inner:?}"
))),
}
}
#[cfg(test)]
mod tests;