fix(postgres): preserve partition child DDL
This commit is contained in:
2 files changed
+371
-79
No files matched your search
@@ -8,6 +8,7 @@ use rustls::client::verify_server_cert_signed_by_trust_anchor;
|
||||
use rustls::crypto::{verify_tls12_signature, verify_tls13_signature, CryptoProvider};
|
||||
use rustls::pki_types::{CertificateDer, PrivateKeyDer, ServerName, UnixTime};
|
||||
use rustls::server::ParsedCertificate;
|
||||
use std::collections::BTreeSet;
|
||||
use std::fs::File;
|
||||
use std::future::Future;
|
||||
use std::io::BufReader;
|
||||
@@ -65,6 +66,22 @@ pub struct PostgresTableAccessInfo {
|
||||
pub privileges: Vec<PostgresTablePrivilegeInfo>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Default, PartialEq, Eq)]
|
||||
pub struct PostgresTablePartitionInfo {
|
||||
pub is_partition: bool,
|
||||
pub parent_schema: Option<String>,
|
||||
pub parent_table: Option<String>,
|
||||
pub bound: Option<String>,
|
||||
pub key: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Default, PartialEq, Eq)]
|
||||
pub struct PostgresTablePartitionLocalObjects {
|
||||
pub has_primary_key: bool,
|
||||
pub foreign_keys: BTreeSet<String>,
|
||||
pub indexes: BTreeSet<String>,
|
||||
}
|
||||
|
||||
fn pg_temporal_to_json_value(row: &Row, idx: usize) -> Option<serde_json::Value> {
|
||||
if let Ok(v) = row.try_get::<_, DateTime<Local>>(idx) {
|
||||
return Some(serde_json::Value::String(format_pg_timestamptz(v)));
|
||||
@@ -2235,40 +2252,115 @@ pub async fn get_table_comment(pool: &Pool, schema: &str, table: &str) -> Result
|
||||
Ok(rows.first().and_then(|row| row.try_get::<_, Option<String>>(0).ok().flatten()).filter(|s| !s.is_empty()))
|
||||
}
|
||||
|
||||
pub async fn get_table_partition_key(pool: &Pool, schema: &str, table: &str) -> Result<Option<String>, String> {
|
||||
pub async fn get_table_partition_info(
|
||||
pool: &Pool,
|
||||
schema: &str,
|
||||
table: &str,
|
||||
) -> Result<PostgresTablePartitionInfo, String> {
|
||||
let schema = if schema.is_empty() { "public" } else { schema };
|
||||
let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
|
||||
// Probe relkind first so PostgreSQL-compatible servers without the PG10
|
||||
// pg_get_partkeydef function keep ordinary-table DDL unchanged.
|
||||
if postgres_query_cached(&client, postgres_partitioned_parent_sql(), &[&schema, &table])
|
||||
.await
|
||||
.map_err(|e| e.to_string())?
|
||||
.is_empty()
|
||||
{
|
||||
return Ok(None);
|
||||
}
|
||||
let rows = postgres_query_cached(&client, postgres_table_partition_key_sql(), &[&schema, &table])
|
||||
let relation_rows = postgres_query_cached(&client, postgres_table_partition_relation_sql(), &[&schema, &table])
|
||||
.await
|
||||
.map_err(|e| e.to_string())?;
|
||||
Ok(rows.first().and_then(|row| row.try_get::<_, Option<String>>(0).ok().flatten()).filter(|s| !s.is_empty()))
|
||||
let Some(relation) = relation_rows.first() else {
|
||||
return Ok(PostgresTablePartitionInfo::default());
|
||||
};
|
||||
let relkind = relation.try_get::<_, String>(0).unwrap_or_default();
|
||||
let is_partition = relation.try_get::<_, bool>(1).unwrap_or(false);
|
||||
if relkind != "p" && !is_partition {
|
||||
return Ok(PostgresTablePartitionInfo::default());
|
||||
}
|
||||
|
||||
let rows = postgres_query_cached(&client, postgres_table_partition_info_sql(), &[&schema, &table])
|
||||
.await
|
||||
.map_err(|e| e.to_string())?;
|
||||
let Some(row) = rows.first() else {
|
||||
return Ok(PostgresTablePartitionInfo { is_partition, ..Default::default() });
|
||||
};
|
||||
Ok(PostgresTablePartitionInfo {
|
||||
is_partition,
|
||||
parent_schema: row.try_get::<_, Option<String>>(0).ok().flatten().filter(|value| !value.is_empty()),
|
||||
parent_table: row.try_get::<_, Option<String>>(1).ok().flatten().filter(|value| !value.is_empty()),
|
||||
bound: row.try_get::<_, Option<String>>(2).ok().flatten().filter(|value| !value.is_empty()),
|
||||
key: row.try_get::<_, Option<String>>(3).ok().flatten().filter(|value| !value.is_empty()),
|
||||
})
|
||||
}
|
||||
|
||||
fn postgres_partitioned_parent_sql() -> &'static str {
|
||||
"SELECT 1 \
|
||||
pub async fn get_table_partition_key(pool: &Pool, schema: &str, table: &str) -> Result<Option<String>, String> {
|
||||
Ok(get_table_partition_info(pool, schema, table).await?.key)
|
||||
}
|
||||
|
||||
pub async fn get_table_partition_local_objects(
|
||||
pool: &Pool,
|
||||
schema: &str,
|
||||
table: &str,
|
||||
) -> Result<PostgresTablePartitionLocalObjects, String> {
|
||||
let schema = if schema.is_empty() { "public" } else { schema };
|
||||
let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
|
||||
let rows = postgres_query_cached(&client, postgres_table_partition_local_objects_sql(), &[&schema, &table])
|
||||
.await
|
||||
.map_err(|e| e.to_string())?;
|
||||
let mut result = PostgresTablePartitionLocalObjects::default();
|
||||
for row in rows {
|
||||
let object_kind = row.try_get::<_, String>(0).unwrap_or_default();
|
||||
let object_name = row.try_get::<_, String>(1).unwrap_or_default();
|
||||
let object_type = row.try_get::<_, Option<String>>(2).ok().flatten().unwrap_or_default();
|
||||
match object_kind.as_str() {
|
||||
"constraint" if object_type == "p" => result.has_primary_key = true,
|
||||
"constraint" if object_type == "f" && !object_name.is_empty() => {
|
||||
result.foreign_keys.insert(object_name);
|
||||
}
|
||||
"index" if !object_name.is_empty() => {
|
||||
result.indexes.insert(object_name);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
fn postgres_table_partition_relation_sql() -> &'static str {
|
||||
"SELECT c.relkind::text, \
|
||||
COALESCE((pg_catalog.row_to_json(c)->>'relispartition')::boolean, false) AS is_partition \
|
||||
FROM pg_catalog.pg_class c \
|
||||
JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
|
||||
WHERE n.nspname = $1 AND c.relname = $2 AND c.relkind = 'p' \
|
||||
WHERE n.nspname = $1 AND c.relname = $2 AND c.relkind IN ('r','p') \
|
||||
LIMIT 1"
|
||||
}
|
||||
|
||||
fn postgres_table_partition_key_sql() -> &'static str {
|
||||
"SELECT pg_catalog.pg_get_partkeydef(c.oid) AS partition_key \
|
||||
fn postgres_table_partition_info_sql() -> &'static str {
|
||||
"SELECT CASE WHEN c.relispartition THEN pn.nspname ELSE NULL END AS parent_schema, \
|
||||
CASE WHEN c.relispartition THEN pc.relname ELSE NULL END AS parent_table, \
|
||||
CASE WHEN c.relispartition THEN pg_catalog.pg_get_expr(c.relpartbound, c.oid, true) ELSE NULL END AS partition_bound, \
|
||||
CASE WHEN c.relkind = 'p' THEN pg_catalog.pg_get_partkeydef(c.oid) ELSE NULL END AS partition_key \
|
||||
FROM pg_catalog.pg_class c \
|
||||
JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
|
||||
WHERE n.nspname = $1 AND c.relname = $2 AND c.relkind = 'p' \
|
||||
LEFT JOIN pg_catalog.pg_inherits i ON i.inhrelid = c.oid \
|
||||
LEFT JOIN pg_catalog.pg_class pc ON pc.oid = i.inhparent \
|
||||
LEFT JOIN pg_catalog.pg_namespace pn ON pn.oid = pc.relnamespace \
|
||||
WHERE n.nspname = $1 AND c.relname = $2 AND c.relkind IN ('r','p') \
|
||||
ORDER BY i.inhseqno NULLS LAST \
|
||||
LIMIT 1"
|
||||
}
|
||||
|
||||
fn postgres_table_partition_local_objects_sql() -> &'static str {
|
||||
"SELECT 'constraint'::text AS object_kind, con.conname AS object_name, con.contype::text AS object_type \
|
||||
FROM pg_catalog.pg_constraint con \
|
||||
JOIN pg_catalog.pg_class c ON c.oid = con.conrelid \
|
||||
JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
|
||||
WHERE n.nspname = $1 AND c.relname = $2 AND con.contype IN ('p','f') \
|
||||
AND COALESCE(NULLIF(pg_catalog.row_to_json(con)->>'conparentid', '')::oid, 0) = 0 \
|
||||
UNION ALL \
|
||||
SELECT 'index'::text AS object_kind, idx.relname AS object_name, NULL::text AS object_type \
|
||||
FROM pg_catalog.pg_index ix \
|
||||
JOIN pg_catalog.pg_class c ON c.oid = ix.indrelid \
|
||||
JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
|
||||
JOIN pg_catalog.pg_class idx ON idx.oid = ix.indexrelid \
|
||||
WHERE n.nspname = $1 AND c.relname = $2 \
|
||||
AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_inherits i WHERE i.inhrelid = idx.oid) \
|
||||
ORDER BY object_kind, object_name"
|
||||
}
|
||||
|
||||
fn postgres_table_comment_sql() -> &'static str {
|
||||
"SELECT obj_description(c.oid) AS table_comment \
|
||||
FROM pg_catalog.pg_class c \
|
||||
@@ -5448,18 +5540,21 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn postgres_table_partition_key_sql_targets_partitioned_parents() {
|
||||
let parent_sql = postgres_partitioned_parent_sql();
|
||||
let sql = postgres_table_partition_key_sql();
|
||||
fn postgres_table_partition_sql_tracks_parents_bounds_and_local_objects() {
|
||||
let relation_sql = postgres_table_partition_relation_sql();
|
||||
let info_sql = postgres_table_partition_info_sql();
|
||||
let local_objects_sql = postgres_table_partition_local_objects_sql();
|
||||
|
||||
assert!(parent_sql.contains("n.nspname = $1"));
|
||||
assert!(parent_sql.contains("c.relname = $2"));
|
||||
assert!(parent_sql.contains("c.relkind = 'p'"));
|
||||
assert!(sql.contains("pg_catalog.pg_get_partkeydef(c.oid)"));
|
||||
assert!(sql.contains("n.nspname = $1"));
|
||||
assert!(sql.contains("c.relname = $2"));
|
||||
assert!(sql.contains("c.relkind = 'p'"));
|
||||
assert!(!sql.contains("pg_get_expr(c.relpartbound"));
|
||||
assert!(relation_sql.contains("row_to_json(c)->>'relispartition'"));
|
||||
assert!(relation_sql.contains("c.relkind IN ('r','p')"));
|
||||
assert!(info_sql.contains("pg_catalog.pg_get_expr(c.relpartbound, c.oid, true)"));
|
||||
assert!(info_sql.contains("pg_catalog.pg_get_partkeydef(c.oid)"));
|
||||
assert!(info_sql.contains("pg_catalog.pg_inherits"));
|
||||
assert!(info_sql.contains("parent_schema"));
|
||||
assert!(info_sql.contains("parent_table"));
|
||||
assert!(local_objects_sql.contains("row_to_json(con)->>'conparentid'"));
|
||||
assert!(local_objects_sql.contains("con.contype IN ('p','f')"));
|
||||
assert!(local_objects_sql.contains("i.inhrelid = idx.oid"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -5605,34 +5700,93 @@ mod tests {
|
||||
|
||||
#[tokio::test]
|
||||
#[ignore = "requires DBX_TEST_POSTGRES_URL pointing at a writable PostgreSQL database"]
|
||||
async fn postgres_partition_key_metadata_reads_parent_only() {
|
||||
async fn postgres_partition_metadata_renders_replayable_children_and_subpartitions() {
|
||||
let url = std::env::var("DBX_TEST_POSTGRES_URL").expect("DBX_TEST_POSTGRES_URL");
|
||||
let pool = connect(&url, Duration::from_secs(5)).await.expect("connect postgres");
|
||||
let schema = format!("dbx_partition_meta_{}", std::process::id());
|
||||
let schema_ident = pg_quote_ident(&schema);
|
||||
let replay_schema = format!("{schema}_replay");
|
||||
let replay_schema_ident = pg_quote_ident(&replay_schema);
|
||||
let parent = format!("{schema_ident}.parent");
|
||||
let child = format!("{schema_ident}.child");
|
||||
let default_child = format!("{schema_ident}.child_default");
|
||||
let subpartition = format!("{schema_ident}.subpartition");
|
||||
let inherited_parent = format!("{schema_ident}.inherited_parent");
|
||||
let inherited_child = format!("{schema_ident}.inherited_child");
|
||||
|
||||
execute_query(&pool, &format!("CREATE SCHEMA {schema_ident}")).await.expect("create schema");
|
||||
let client = pool.get().await.expect("get postgres client");
|
||||
client
|
||||
.batch_execute(&format!(
|
||||
"CREATE TABLE {parent} (id integer, payload text) PARTITION BY RANGE (id); \
|
||||
CREATE TABLE {child} PARTITION OF {parent} FOR VALUES FROM (1) TO (10)"
|
||||
CREATE TABLE {child} PARTITION OF {parent} (PRIMARY KEY (id)) FOR VALUES FROM (1) TO (10); \
|
||||
CREATE INDEX child_payload_idx ON {child} (payload); \
|
||||
CREATE TABLE {default_child} PARTITION OF {parent} DEFAULT; \
|
||||
CREATE TABLE {subpartition} PARTITION OF {parent} FOR VALUES FROM (10) TO (20) PARTITION BY HASH (payload); \
|
||||
CREATE TABLE {inherited_parent} (id integer, bucket integer, PRIMARY KEY (id, bucket)) PARTITION BY RANGE (bucket); \
|
||||
CREATE TABLE {inherited_child} PARTITION OF {inherited_parent} FOR VALUES FROM (1) TO (10)"
|
||||
))
|
||||
.await
|
||||
.expect("create partitioned tables");
|
||||
|
||||
let parent_key = get_table_partition_key(&pool, &schema, "parent").await.expect("parent metadata");
|
||||
let child_key = get_table_partition_key(&pool, &schema, "child").await.expect("child metadata");
|
||||
let parent_info = get_table_partition_info(&pool, &schema, "parent").await.expect("parent metadata");
|
||||
let child_info = get_table_partition_info(&pool, &schema, "child").await.expect("child metadata");
|
||||
let default_info = get_table_partition_info(&pool, &schema, "child_default").await.expect("default metadata");
|
||||
let subpartition_info =
|
||||
get_table_partition_info(&pool, &schema, "subpartition").await.expect("subpartition metadata");
|
||||
let child_local_objects =
|
||||
get_table_partition_local_objects(&pool, &schema, "child").await.expect("child local objects");
|
||||
let inherited_child_local_objects = get_table_partition_local_objects(&pool, &schema, "inherited_child")
|
||||
.await
|
||||
.expect("inherited child local objects");
|
||||
let parent_ddl = crate::schema::pg_ddl(&pool, &schema, "parent").await.expect("parent ddl");
|
||||
let child_ddl = crate::schema::pg_ddl(&pool, &schema, "child").await.expect("child ddl");
|
||||
let default_ddl = crate::schema::pg_ddl(&pool, &schema, "child_default").await.expect("default ddl");
|
||||
let subpartition_ddl = crate::schema::pg_ddl(&pool, &schema, "subpartition").await.expect("subpartition ddl");
|
||||
let inherited_parent_ddl =
|
||||
crate::schema::pg_ddl(&pool, &schema, "inherited_parent").await.expect("inherited parent ddl");
|
||||
let inherited_child_ddl =
|
||||
crate::schema::pg_ddl(&pool, &schema, "inherited_child").await.expect("inherited child ddl");
|
||||
|
||||
execute_query(&pool, &format!("DROP SCHEMA {schema_ident} CASCADE")).await.expect("drop schema");
|
||||
execute_query(&pool, &format!("CREATE SCHEMA {replay_schema_ident}")).await.expect("create replay schema");
|
||||
for ddl in
|
||||
[&parent_ddl, &child_ddl, &default_ddl, &subpartition_ddl, &inherited_parent_ddl, &inherited_child_ddl]
|
||||
{
|
||||
client
|
||||
.batch_execute(&ddl.replace(&schema_ident, &replay_schema_ident))
|
||||
.await
|
||||
.unwrap_or_else(|error| panic!("replay partition ddl failed: {error}; ddl: {ddl}"));
|
||||
}
|
||||
|
||||
assert_eq!(parent_key, Some("RANGE (id)".to_string()));
|
||||
assert_eq!(child_key, None);
|
||||
client
|
||||
.batch_execute(&format!("DROP SCHEMA {schema_ident} CASCADE; DROP SCHEMA {replay_schema_ident} CASCADE"))
|
||||
.await
|
||||
.expect("drop schemas");
|
||||
|
||||
assert_eq!(parent_info.key.as_deref(), Some("RANGE (id)"));
|
||||
assert!(!parent_info.is_partition);
|
||||
assert_eq!(child_info.parent_schema.as_deref(), Some(schema.as_str()));
|
||||
assert_eq!(child_info.parent_table.as_deref(), Some("parent"));
|
||||
assert_eq!(child_info.bound.as_deref(), Some("FOR VALUES FROM (1) TO (10)"));
|
||||
assert!(child_local_objects.has_primary_key);
|
||||
assert!(child_local_objects.indexes.contains("child_payload_idx"));
|
||||
assert!(!inherited_child_local_objects.has_primary_key);
|
||||
assert!(inherited_child_local_objects.indexes.is_empty());
|
||||
assert_eq!(default_info.bound.as_deref(), Some("DEFAULT"));
|
||||
assert_eq!(subpartition_info.key.as_deref(), Some("HASH (payload)"));
|
||||
assert!(parent_ddl.contains(") PARTITION BY RANGE (id);"), "ddl: {parent_ddl}");
|
||||
assert!(!parent_ddl.contains("PARTITION OF"));
|
||||
assert!(child_ddl.contains("CREATE TABLE"), "ddl: {child_ddl}");
|
||||
assert!(child_ddl.contains("PARTITION OF"), "ddl: {child_ddl}");
|
||||
assert!(child_ddl.contains("PRIMARY KEY (\"id\")"), "ddl: {child_ddl}");
|
||||
assert!(child_ddl.contains("FOR VALUES FROM (1) TO (10);"), "ddl: {child_ddl}");
|
||||
assert!(child_ddl.contains("CREATE INDEX \"child_payload_idx\""), "ddl: {child_ddl}");
|
||||
assert!(default_ddl.contains(" DEFAULT;"), "ddl: {default_ddl}");
|
||||
assert!(
|
||||
subpartition_ddl.contains("FOR VALUES FROM (10) TO (20) PARTITION BY HASH (payload);"),
|
||||
"ddl: {subpartition_ddl}"
|
||||
);
|
||||
assert!(!inherited_child_ddl.contains("PRIMARY KEY"), "ddl: {inherited_child_ddl}");
|
||||
assert!(!inherited_child_ddl.contains("CREATE INDEX"), "ddl: {inherited_child_ddl}");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
|
||||
+180
-42
@@ -7674,14 +7674,18 @@ mod ddl_tests {
|
||||
"HASH ((lower(code)))",
|
||||
"RANGE (date_trunc('month'::text, created_at))",
|
||||
] {
|
||||
let ddl = render_postgres_table_ddl_with_partition_key(
|
||||
let ddl = render_postgres_table_ddl_with_partition_info(
|
||||
"public",
|
||||
"events",
|
||||
&[column("created_at", "timestamp without time zone")],
|
||||
&[],
|
||||
&[],
|
||||
None,
|
||||
Some(partition_key),
|
||||
&db::postgres::PostgresTablePartitionInfo {
|
||||
key: Some(partition_key.to_string()),
|
||||
..Default::default()
|
||||
},
|
||||
&db::postgres::PostgresTablePartitionLocalObjects::default(),
|
||||
);
|
||||
|
||||
assert!(ddl.ends_with(&format!(") PARTITION BY {partition_key};\n")), "ddl: {ddl}");
|
||||
@@ -7691,20 +7695,103 @@ mod ddl_tests {
|
||||
|
||||
#[test]
|
||||
fn postgres_table_ddl_keeps_ordinary_table_unchanged() {
|
||||
let ddl = render_postgres_table_ddl_with_partition_key(
|
||||
let ddl = render_postgres_table_ddl_with_partition_info(
|
||||
"public",
|
||||
"users",
|
||||
&[column("id", "integer")],
|
||||
&[],
|
||||
&[],
|
||||
None,
|
||||
None,
|
||||
&db::postgres::PostgresTablePartitionInfo::default(),
|
||||
&db::postgres::PostgresTablePartitionLocalObjects::default(),
|
||||
);
|
||||
|
||||
assert!(ddl.ends_with(");\n"), "ddl: {ddl}");
|
||||
assert!(!ddl.contains("PARTITION BY"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn postgres_table_ddl_renders_partition_children_and_subpartitions() {
|
||||
let mut id = column("id", "integer");
|
||||
id.is_primary_key = true;
|
||||
let indexes = vec![db::IndexInfo {
|
||||
name: "events_payload_idx".to_string(),
|
||||
columns: vec!["payload".to_string()],
|
||||
is_unique: false,
|
||||
is_primary: false,
|
||||
filter: None,
|
||||
index_type: Some("btree".to_string()),
|
||||
included_columns: None,
|
||||
comment: None,
|
||||
}];
|
||||
let partition_info = db::postgres::PostgresTablePartitionInfo {
|
||||
is_partition: true,
|
||||
parent_schema: Some("public".to_string()),
|
||||
parent_table: Some("events".to_string()),
|
||||
bound: Some("FOR VALUES FROM ('2026-01-01') TO ('2027-01-01')".to_string()),
|
||||
key: Some("HASH (payload)".to_string()),
|
||||
};
|
||||
let partition_local_objects = db::postgres::PostgresTablePartitionLocalObjects {
|
||||
has_primary_key: true,
|
||||
foreign_keys: BTreeSet::new(),
|
||||
indexes: BTreeSet::from(["events_payload_idx".to_string()]),
|
||||
};
|
||||
|
||||
let ddl = render_postgres_table_ddl_with_partition_info(
|
||||
"public",
|
||||
"events_2026",
|
||||
&[id, column("payload", "text")],
|
||||
&indexes,
|
||||
&[],
|
||||
None,
|
||||
&partition_info,
|
||||
&partition_local_objects,
|
||||
);
|
||||
|
||||
assert!(ddl.starts_with(
|
||||
"CREATE TABLE \"public\".\"events_2026\" PARTITION OF \"public\".\"events\" (\n PRIMARY KEY (\"id\")\n)"
|
||||
));
|
||||
assert!(ddl.contains("FOR VALUES FROM ('2026-01-01') TO ('2027-01-01') PARTITION BY HASH (payload);"));
|
||||
assert!(ddl.contains("CREATE INDEX \"events_payload_idx\""));
|
||||
assert!(!ddl.contains("\"payload\" text"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn postgres_partition_ddl_skips_inherited_constraints_and_indexes() {
|
||||
let mut id = column("id", "integer");
|
||||
id.is_primary_key = true;
|
||||
let indexes = vec![db::IndexInfo {
|
||||
name: "events_2026_pkey".to_string(),
|
||||
columns: vec!["id".to_string()],
|
||||
is_unique: true,
|
||||
is_primary: true,
|
||||
filter: None,
|
||||
index_type: Some("btree".to_string()),
|
||||
included_columns: None,
|
||||
comment: None,
|
||||
}];
|
||||
let partition_info = db::postgres::PostgresTablePartitionInfo {
|
||||
is_partition: true,
|
||||
parent_schema: Some("public".to_string()),
|
||||
parent_table: Some("events".to_string()),
|
||||
bound: Some("DEFAULT".to_string()),
|
||||
key: None,
|
||||
};
|
||||
|
||||
let ddl = render_postgres_table_ddl_with_partition_info(
|
||||
"public",
|
||||
"events_default",
|
||||
&[id],
|
||||
&indexes,
|
||||
&[],
|
||||
None,
|
||||
&partition_info,
|
||||
&db::postgres::PostgresTablePartitionLocalObjects::default(),
|
||||
);
|
||||
|
||||
assert_eq!(ddl, "CREATE TABLE \"public\".\"events_default\" PARTITION OF \"public\".\"events\" DEFAULT;\n");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn postgres_table_ddl_keeps_composite_foreign_key_together() {
|
||||
let columns = vec![column("a", "integer"), column("b", "integer"), column("c", "integer")];
|
||||
@@ -7939,24 +8026,30 @@ pub async fn sqlite_ddl(pool: &db::sqlite::SqliteHandle, schema: &str, table: &s
|
||||
}
|
||||
|
||||
pub async fn pg_ddl(pool: &deadpool_postgres::Pool, schema: &str, table: &str) -> Result<String, String> {
|
||||
let (columns, indexes, fkeys, table_comment, partition_key, trigger_definitions) = tokio::try_join!(
|
||||
let (columns, indexes, fkeys, table_comment, partition_info, trigger_definitions) = tokio::try_join!(
|
||||
db::postgres::get_columns(pool, schema, table),
|
||||
db::postgres::list_indexes(pool, schema, table),
|
||||
db::postgres::list_foreign_keys(pool, schema, table),
|
||||
async { db::postgres::get_table_comment(pool, schema, table).await },
|
||||
db::postgres::get_table_partition_key(pool, schema, table),
|
||||
db::postgres::get_table_partition_info(pool, schema, table),
|
||||
db::postgres::list_trigger_definitions(pool, schema, table),
|
||||
)?;
|
||||
let partition_local_objects = if partition_info.is_partition {
|
||||
db::postgres::get_table_partition_local_objects(pool, schema, table).await?
|
||||
} else {
|
||||
db::postgres::PostgresTablePartitionLocalObjects::default()
|
||||
};
|
||||
|
||||
Ok(append_postgres_trigger_definitions(
|
||||
render_postgres_table_ddl_with_partition_key(
|
||||
render_postgres_table_ddl_with_partition_info(
|
||||
schema,
|
||||
table,
|
||||
&columns,
|
||||
&indexes,
|
||||
&fkeys,
|
||||
table_comment.as_deref(),
|
||||
partition_key.as_deref(),
|
||||
&partition_info,
|
||||
&partition_local_objects,
|
||||
),
|
||||
&trigger_definitions,
|
||||
))
|
||||
@@ -8248,68 +8341,110 @@ pub fn render_postgres_table_ddl(
|
||||
fkeys: &[db::ForeignKeyInfo],
|
||||
table_comment: Option<&str>,
|
||||
) -> String {
|
||||
render_postgres_table_ddl_with_partition_key(schema, table, columns, indexes, fkeys, table_comment, None)
|
||||
render_postgres_table_ddl_with_partition_info(
|
||||
schema,
|
||||
table,
|
||||
columns,
|
||||
indexes,
|
||||
fkeys,
|
||||
table_comment,
|
||||
&db::postgres::PostgresTablePartitionInfo::default(),
|
||||
&db::postgres::PostgresTablePartitionLocalObjects::default(),
|
||||
)
|
||||
}
|
||||
|
||||
fn render_postgres_table_ddl_with_partition_key(
|
||||
fn render_postgres_table_ddl_with_partition_info(
|
||||
schema: &str,
|
||||
table: &str,
|
||||
columns: &[db::ColumnInfo],
|
||||
indexes: &[db::IndexInfo],
|
||||
fkeys: &[db::ForeignKeyInfo],
|
||||
table_comment: Option<&str>,
|
||||
partition_key: Option<&str>,
|
||||
partition_info: &db::postgres::PostgresTablePartitionInfo,
|
||||
partition_local_objects: &db::postgres::PostgresTablePartitionLocalObjects,
|
||||
) -> String {
|
||||
let table_name = format!("{}.{}", pg_ident(schema), pg_ident(table));
|
||||
let mut ddl = format!("CREATE TABLE {table_name} (\n");
|
||||
let col_lines: Vec<String> = columns
|
||||
.iter()
|
||||
.map(|c| {
|
||||
let mut line = format!(" {} {}", pg_ident(&c.name), c.data_type);
|
||||
let generated_clause = c
|
||||
.extra
|
||||
.as_deref()
|
||||
.map(str::trim)
|
||||
.filter(|value| !value.is_empty() && value.to_ascii_lowercase().starts_with("generated "));
|
||||
if let Some(extra) = generated_clause {
|
||||
line.push_str(&format!(" {extra}"));
|
||||
}
|
||||
if !c.is_nullable {
|
||||
line.push_str(" NOT NULL");
|
||||
}
|
||||
if generated_clause.is_none() {
|
||||
if let Some(ref def) = c.column_default {
|
||||
line.push_str(&format!(" DEFAULT {def}"));
|
||||
}
|
||||
}
|
||||
line
|
||||
let partition_parent = partition_info
|
||||
.is_partition
|
||||
.then(|| {
|
||||
Some((
|
||||
partition_info.parent_schema.as_deref()?,
|
||||
partition_info.parent_table.as_deref()?,
|
||||
partition_info.bound.as_deref()?,
|
||||
))
|
||||
})
|
||||
.collect();
|
||||
ddl.push_str(&col_lines.join(",\n"));
|
||||
.flatten();
|
||||
let is_partition = partition_parent.is_some();
|
||||
let mut definition_lines = if is_partition {
|
||||
Vec::new()
|
||||
} else {
|
||||
columns
|
||||
.iter()
|
||||
.map(|c| {
|
||||
let mut line = format!(" {} {}", pg_ident(&c.name), c.data_type);
|
||||
let generated_clause = c
|
||||
.extra
|
||||
.as_deref()
|
||||
.map(str::trim)
|
||||
.filter(|value| !value.is_empty() && value.to_ascii_lowercase().starts_with("generated "));
|
||||
if let Some(extra) = generated_clause {
|
||||
line.push_str(&format!(" {extra}"));
|
||||
}
|
||||
if !c.is_nullable {
|
||||
line.push_str(" NOT NULL");
|
||||
}
|
||||
if generated_clause.is_none() {
|
||||
if let Some(ref def) = c.column_default {
|
||||
line.push_str(&format!(" DEFAULT {def}"));
|
||||
}
|
||||
}
|
||||
line
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
};
|
||||
|
||||
let pks: Vec<&str> = columns.iter().filter(|c| c.is_primary_key).map(|c| c.name.as_str()).collect();
|
||||
let pks: Vec<&str> = if !is_partition || partition_local_objects.has_primary_key {
|
||||
columns.iter().filter(|c| c.is_primary_key).map(|c| c.name.as_str()).collect()
|
||||
} else {
|
||||
Vec::new()
|
||||
};
|
||||
if !pks.is_empty() {
|
||||
ddl.push_str(&format!(",\n PRIMARY KEY ({})", pks.iter().map(|k| pg_ident(k)).collect::<Vec<_>>().join(", ")));
|
||||
definition_lines
|
||||
.push(format!(" PRIMARY KEY ({})", pks.iter().map(|key| pg_ident(key)).collect::<Vec<_>>().join(", ")));
|
||||
}
|
||||
for fk_group in group_foreign_keys_by_name(fkeys) {
|
||||
let Some(first_fk) = fk_group.first() else {
|
||||
continue;
|
||||
};
|
||||
if is_partition && !partition_local_objects.foreign_keys.contains(&first_fk.name) {
|
||||
continue;
|
||||
}
|
||||
let columns = fk_group.iter().map(|fk| pg_ident(&fk.column)).collect::<Vec<_>>().join(", ");
|
||||
let ref_columns = fk_group.iter().map(|fk| pg_ident(&fk.ref_column)).collect::<Vec<_>>().join(", ");
|
||||
ddl.push_str(&format!(
|
||||
",\n CONSTRAINT {} FOREIGN KEY ({}) REFERENCES {}({})",
|
||||
definition_lines.push(format!(
|
||||
" CONSTRAINT {} FOREIGN KEY ({}) REFERENCES {}({})",
|
||||
pg_ident(&first_fk.name),
|
||||
columns,
|
||||
pg_ident(&first_fk.ref_table),
|
||||
ref_columns
|
||||
));
|
||||
}
|
||||
if let Some(partition_key) = partition_key.filter(|key| !key.trim().is_empty()) {
|
||||
ddl.push_str(&format!("\n) PARTITION BY {partition_key};\n"));
|
||||
|
||||
let mut ddl = if let Some((parent_schema, parent_table, bound)) = partition_parent {
|
||||
let parent_name = format!("{}.{}", pg_ident(parent_schema), pg_ident(parent_table));
|
||||
let definitions = if definition_lines.is_empty() {
|
||||
String::new()
|
||||
} else {
|
||||
format!(" (\n{}\n)", definition_lines.join(",\n"))
|
||||
};
|
||||
format!("CREATE TABLE {table_name} PARTITION OF {parent_name}{definitions} {bound}")
|
||||
} else {
|
||||
ddl.push_str("\n);\n");
|
||||
format!("CREATE TABLE {table_name} (\n{}\n)", definition_lines.join(",\n"))
|
||||
};
|
||||
if let Some(partition_key) = partition_info.key.as_deref().filter(|key| !key.trim().is_empty()) {
|
||||
ddl.push_str(&format!(" PARTITION BY {partition_key}"));
|
||||
}
|
||||
ddl.push_str(";\n");
|
||||
|
||||
if let Some(comment) = table_comment.filter(|comment| !comment.trim().is_empty()) {
|
||||
ddl.push_str(&format!("\nCOMMENT ON TABLE {table_name} IS {};", sql_string(comment)));
|
||||
@@ -8329,6 +8464,9 @@ fn render_postgres_table_ddl_with_partition_key(
|
||||
if idx.is_primary {
|
||||
continue;
|
||||
}
|
||||
if is_partition && !partition_local_objects.indexes.contains(&idx.name) {
|
||||
continue;
|
||||
}
|
||||
let unique = if idx.is_unique { "UNIQUE " } else { "" };
|
||||
let cols = idx.columns.iter().map(|c| pg_ident(c)).collect::<Vec<_>>().join(", ");
|
||||
let using = idx.index_type.as_deref().map(|t| format!(" USING {t}")).unwrap_or_default();
|
||||
|
||||
Reference in new issue
Block a user