#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub enum FieldType {
Standard,
Bool,
Json,
Jsonb,
DateTime,
TimestampTz,
Date,
Time,
Uuid,
Timestamp,
Decimal,
Blob,
Text,
Array(Box<FieldType>),
Inet,
Cidr,
MacAddr,
MacAddr8,
Bit,
Varbit,
Range(Box<FieldType>),
Multirange(Box<FieldType>),
}
impl FieldType {
pub fn postgres_type_name(&self) -> Option<String> {
Some(match self {
Self::Standard => return None,
Self::Bool => "boolean".to_string(),
Self::Array(inner) => format!("{}[]", inner.postgres_type_name()?),
Self::Json => "json".to_string(),
Self::Jsonb => "jsonb".to_string(),
Self::DateTime => "timestamp".to_string(),
Self::TimestampTz => "timestamptz".to_string(),
Self::Date => "date".to_string(),
Self::Time => "time".to_string(),
Self::Uuid => "uuid".to_string(),
Self::Timestamp => "bigint".to_string(),
Self::Decimal => "numeric".to_string(),
Self::Blob => "bytea".to_string(),
Self::Text => "text".to_string(),
Self::Inet => "inet".to_string(),
Self::Cidr => "cidr".to_string(),
Self::MacAddr => "macaddr".to_string(),
Self::MacAddr8 => "macaddr8".to_string(),
Self::Bit => "bit".to_string(),
Self::Varbit => "varbit".to_string(),
Self::Range(inner) => range_type_name(inner, false)?.to_string(),
Self::Multirange(inner) => range_type_name(inner, true)?.to_string(),
})
}
}
fn range_type_name(element: &FieldType, multirange: bool) -> Option<&'static str> {
Some(match (element, multirange) {
(FieldType::Standard, false) => "int4range",
(FieldType::Standard, true) => "int4multirange",
(FieldType::Timestamp, false) => "int8range",
(FieldType::Timestamp, true) => "int8multirange",
(FieldType::Decimal, false) => "numrange",
(FieldType::Decimal, true) => "nummultirange",
(FieldType::DateTime, false) => "tsrange",
(FieldType::DateTime, true) => "tsmultirange",
(FieldType::TimestampTz, false) => "tstzrange",
(FieldType::TimestampTz, true) => "tstzmultirange",
(FieldType::Date, false) => "daterange",
(FieldType::Date, true) => "datemultirange",
_ => return None,
})
}
pub const SESSION_GUC_BASELINE: &[(&str, &str)] = &[
("TimeZone", "UTC"),
("DateStyle", "ISO, YMD"),
("IntervalStyle", "postgres"),
("extra_float_digits", "3"),
("standard_conforming_strings", "on"),
];
#[derive(Debug, Clone)]
#[non_exhaustive]
pub enum JoinType {
Inner,
Left,
Right,
}
#[derive(Debug, Clone)]
pub struct JoinClause {
pub join_type: JoinType,
pub table: String,
pub on: String,
}
#[derive(Debug, Clone)]
pub struct OrderClause {
pub field: String,
pub asc: bool,
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used)]
mod tests {
use super::*;
#[test]
fn postgres_type_name_maps_existing_and_new_types() {
let cases = [
(FieldType::Bool, "boolean"),
(FieldType::Json, "json"),
(FieldType::Jsonb, "jsonb"),
(FieldType::DateTime, "timestamp"),
(FieldType::TimestampTz, "timestamptz"),
(FieldType::Date, "date"),
(FieldType::Time, "time"),
(FieldType::Uuid, "uuid"),
(FieldType::Timestamp, "bigint"),
(FieldType::Decimal, "numeric"),
(FieldType::Blob, "bytea"),
(FieldType::Text, "text"),
(FieldType::Inet, "inet"),
(FieldType::Cidr, "cidr"),
(FieldType::MacAddr, "macaddr"),
(FieldType::MacAddr8, "macaddr8"),
(FieldType::Bit, "bit"),
(FieldType::Varbit, "varbit"),
];
for (field_type, expected) in cases {
assert_eq!(
field_type.postgres_type_name().as_deref(),
Some(expected),
"{field_type:?} 应映射到 PostgreSQL 类型名 {expected}"
);
}
}
#[test]
fn postgres_type_name_is_recursive_for_arrays() {
assert_eq!(
FieldType::Array(Box::new(FieldType::Text))
.postgres_type_name()
.as_deref(),
Some("text[]")
);
assert_eq!(
FieldType::Array(Box::new(FieldType::Inet))
.postgres_type_name()
.as_deref(),
Some("inet[]")
);
assert_eq!(
FieldType::Array(Box::new(FieldType::Blob))
.postgres_type_name()
.as_deref(),
Some("bytea[]")
);
assert_eq!(
FieldType::Array(Box::new(FieldType::Standard)).postgres_type_name(),
None
);
assert_eq!(FieldType::Standard.postgres_type_name(), None);
}
#[test]
fn postgres_type_name_maps_builtin_range_and_multirange_types() {
let ranges = [
(FieldType::Standard, "int4range", "int4multirange"),
(FieldType::Timestamp, "int8range", "int8multirange"),
(FieldType::Decimal, "numrange", "nummultirange"),
(FieldType::DateTime, "tsrange", "tsmultirange"),
(FieldType::TimestampTz, "tstzrange", "tstzmultirange"),
(FieldType::Date, "daterange", "datemultirange"),
];
for (element, range, multirange) in ranges {
assert_eq!(
FieldType::Range(Box::new(element.clone()))
.postgres_type_name()
.as_deref(),
Some(range),
"Range({element:?}) 应映射到 {range}"
);
assert_eq!(
FieldType::Multirange(Box::new(element))
.postgres_type_name()
.as_deref(),
Some(multirange)
);
}
for element in [FieldType::Text, FieldType::Json, FieldType::Uuid] {
assert_eq!(
FieldType::Range(Box::new(element.clone())).postgres_type_name(),
None
);
assert_eq!(
FieldType::Multirange(Box::new(element)).postgres_type_name(),
None
);
}
}
#[test]
fn session_guc_baseline_pins_deterministic_formats() {
assert_eq!(
SESSION_GUC_BASELINE,
[
("TimeZone", "UTC"),
("DateStyle", "ISO, YMD"),
("IntervalStyle", "postgres"),
("extra_float_digits", "3"),
("standard_conforming_strings", "on"),
]
.as_slice(),
"会话 GUC 基线是类型编解码确定性的契约,变更需同步文档与集成测试"
);
}
#[test]
fn session_guc_baseline_datestyle_matches_set_statement() {
let datestyle = SESSION_GUC_BASELINE
.iter()
.find(|(name, _)| *name == "DateStyle")
.map(|(_, value)| *value)
.expect("基线必须包含 DateStyle");
assert_eq!(datestyle, "ISO, YMD");
}
}