From 8a6640e184cc254768e757ac1b348721cbe423b9 Mon Sep 17 00:00:00 2001 From: gggaiitx <62124152+gggaiitx@users.noreply.github.com> Date: Mon, 13 Jul 2026 21:06:08 +0800 Subject: [PATCH] fix(ddl): include table comments in generated DDL --- .../java/com/dbx/agent/BaseDatabaseAgent.java | 9 +- .../com/dbx/agent/ConfiguredJdbcAgent.java | 9 +- .../java/com/dbx/agent/DatabaseAgent.java | 46 +++++++++- .../main/java/com/dbx/agent/DdlBuilder.java | 29 +++++- .../java/com/dbx/agent/PostgresLikeAgent.java | 33 ++++++- .../agent/CommonJavaCompatibilityTest.java | 37 ++++++++ .../oceanbaseoracle/OceanBaseOracleAgent.java | 28 +++++- .../OceanBaseOracleAgentTest.java | 4 + .../sqlserverlegacy/SqlServerLegacyAgent.java | 83 +++++++++++++++++ .../SqlServerLegacyAgentTest.java | 35 ++++++++ crates/dbx-core/src/schema.rs | 89 +++++++++++++++++-- crates/dbx-core/src/transfer.rs | 2 +- 12 files changed, 387 insertions(+), 17 deletions(-) diff --git a/agents/common/src/main/java/com/dbx/agent/BaseDatabaseAgent.java b/agents/common/src/main/java/com/dbx/agent/BaseDatabaseAgent.java index bce1d820f7..d8c1076229 100644 --- a/agents/common/src/main/java/com/dbx/agent/BaseDatabaseAgent.java +++ b/agents/common/src/main/java/com/dbx/agent/BaseDatabaseAgent.java @@ -41,7 +41,14 @@ public abstract class BaseDatabaseAgent implements DatabaseAgent { foreignKeys = Collections.emptyList(); } - return DatabaseAgent.buildTableDdl(schema, table, getColumns(schema, table), indexes, foreignKeys); + String tableComment = null; + try { + tableComment = getTableComment(schema, table); + } catch (RuntimeException e) { + // Table comment is optional; DDL generation should still succeed without it. + } + + return DdlBuilder.buildTableDdl(schema, table, getColumns(schema, table), indexes, foreignKeys, Collections.emptyList(), false, false, tableComment); } @Override diff --git a/agents/common/src/main/java/com/dbx/agent/ConfiguredJdbcAgent.java b/agents/common/src/main/java/com/dbx/agent/ConfiguredJdbcAgent.java index 7d75e418ae..fbf1f5eca3 100644 --- a/agents/common/src/main/java/com/dbx/agent/ConfiguredJdbcAgent.java +++ b/agents/common/src/main/java/com/dbx/agent/ConfiguredJdbcAgent.java @@ -144,7 +144,14 @@ public abstract class ConfiguredJdbcAgent extends AbstractJdbcAgent { foreignKeys = Collections.emptyList(); } - return DatabaseAgent.buildTableDdl(schema, table, getColumns(schema, table), indexes, foreignKeys); + String tableComment = null; + try { + tableComment = getTableComment(schema, table); + } catch (RuntimeException e) { + // Table comment is optional; DDL generation should still succeed without it. + } + + return DdlBuilder.buildTableDdl(schema, table, getColumns(schema, table), indexes, foreignKeys, Collections.emptyList(), false, false, tableComment); } @Override diff --git a/agents/common/src/main/java/com/dbx/agent/DatabaseAgent.java b/agents/common/src/main/java/com/dbx/agent/DatabaseAgent.java index 0c8ca64cba..be2233dbba 100644 --- a/agents/common/src/main/java/com/dbx/agent/DatabaseAgent.java +++ b/agents/common/src/main/java/com/dbx/agent/DatabaseAgent.java @@ -82,7 +82,51 @@ public interface DatabaseAgent { foreignKeys = Collections.emptyList(); } - return buildTableDdl(schema, table, getColumns(schema, table), indexes, foreignKeys); + String tableComment = null; + try { + tableComment = getTableComment(schema, table); + } catch (RuntimeException e) { + // Table comment is optional; DDL generation should still succeed without it. + } + + return DdlBuilder.buildTableDdl(schema, table, getColumns(schema, table), indexes, foreignKeys, Collections.emptyList(), false, false, tableComment); + } + + /** + * Returns the comment/description for a table, or null if not available. + * Default implementation looks up the comment from listTables results. + * Subclasses can override for more efficient queries. + */ + default String getTableComment(String schema, String table) { + try { + String caseInsensitiveComment = null; + int caseInsensitiveMatches = 0; + for (TableInfo info : listTables(schema)) { + if (!info.getName().equalsIgnoreCase(table)) { + continue; + } + if (info.getName().equals(table)) { + return nonBlankComment(info.getComment()); + } + caseInsensitiveMatches++; + caseInsensitiveComment = nonBlankComment(info.getComment()); + } + // Case-insensitive databases may normalize metadata names, but quoted + // mixed-case objects must never borrow a sibling table's comment. + if (caseInsensitiveMatches == 1) { + return caseInsensitiveComment; + } + } catch (RuntimeException e) { + // Ignore; table comment is optional. + } + return null; + } + + static String nonBlankComment(String comment) { + if (comment != null && !comment.trim().isEmpty()) { + return comment; + } + return null; } List listIndexes(String schema, String table); diff --git a/agents/common/src/main/java/com/dbx/agent/DdlBuilder.java b/agents/common/src/main/java/com/dbx/agent/DdlBuilder.java index b03ef7e277..304eafb2e1 100644 --- a/agents/common/src/main/java/com/dbx/agent/DdlBuilder.java +++ b/agents/common/src/main/java/com/dbx/agent/DdlBuilder.java @@ -16,7 +16,7 @@ public final class DdlBuilder { List indexes, List foreignKeys ) { - return buildTableDdl(schema, table, columns, indexes, foreignKeys, false, false); + return buildTableDdl(schema, table, columns, indexes, foreignKeys, Collections.emptyList(), false, false, null); } public static String buildTableDdl( @@ -27,7 +27,7 @@ public final class DdlBuilder { List foreignKeys, boolean useBacktick ) { - return buildTableDdl(schema, table, columns, indexes, foreignKeys, useBacktick, false); + return buildTableDdl(schema, table, columns, indexes, foreignKeys, Collections.emptyList(), useBacktick, false, null); } public static String buildTableDdl( @@ -47,7 +47,8 @@ public final class DdlBuilder { foreignKeys, Collections.emptyList(), useBacktick, - includeColumnComments + includeColumnComments, + null ); } @@ -60,6 +61,20 @@ public final class DdlBuilder { List checkConstraints, boolean useBacktick, boolean includeColumnComments + ) { + return buildTableDdl(schema, table, columns, indexes, foreignKeys, checkConstraints, useBacktick, includeColumnComments, null); + } + + public static String buildTableDdl( + String schema, + String table, + List columns, + List indexes, + List foreignKeys, + List checkConstraints, + boolean useBacktick, + boolean includeColumnComments, + String tableComment ) { String tableRef = qualifiedName(schema, table, useBacktick); List columnLines = new ArrayList<>(); @@ -114,6 +129,14 @@ public final class DdlBuilder { ddl.append(join(columnLines, ",\n")); ddl.append("\n);\n"); + if (notBlank(tableComment)) { + ddl.append("\nCOMMENT ON TABLE "); + ddl.append(tableRef); + ddl.append(" IS '"); + ddl.append(sqlStringBody(tableComment)); + ddl.append("';"); + } + if (includeColumnComments) { for (ColumnInfo column : columns) { if (!notBlank(column.getComment())) { diff --git a/agents/common/src/main/java/com/dbx/agent/PostgresLikeAgent.java b/agents/common/src/main/java/com/dbx/agent/PostgresLikeAgent.java index ecba927181..36f70a7611 100644 --- a/agents/common/src/main/java/com/dbx/agent/PostgresLikeAgent.java +++ b/agents/common/src/main/java/com/dbx/agent/PostgresLikeAgent.java @@ -259,6 +259,13 @@ public abstract class PostgresLikeAgent extends AbstractJdbcAgent { checkConstraints = Collections.emptyList(); } + String tableComment = null; + try { + tableComment = getTableComment(schema, table); + } catch (RuntimeException e) { + // Table comment is optional; DDL generation should still succeed without it. + } + return DdlBuilder.buildTableDdl( schema, table, @@ -267,10 +274,34 @@ public abstract class PostgresLikeAgent extends AbstractJdbcAgent { foreignKeys, checkConstraints, mysqlCompatMode, - true + true, + tableComment ); } + @Override + public String getTableComment(String schema, String table) { + return unchecked(() -> { + try (java.sql.PreparedStatement stmt = requireConnection().prepareStatement( + "SELECT obj_description(c.oid) AS table_comment " + + "FROM pg_catalog.pg_class c " + + "JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace " + + "WHERE n.nspname = ? AND c.relname = ? AND c.relkind IN ('r','m','f','p') " + + "LIMIT 1" + )) { + stmt.setString(1, schema); + stmt.setString(2, table); + try (ResultSet rs = stmt.executeQuery()) { + if (rs.next()) { + String comment = rs.getString("table_comment"); + return (comment != null && !comment.trim().isEmpty()) ? comment : null; + } + } + } + return null; + }); + } + protected List listCheckConstraints(String schema, String table) { return unchecked(() -> { List result = new ArrayList<>(); diff --git a/agents/common/src/test/java/com/dbx/agent/CommonJavaCompatibilityTest.java b/agents/common/src/test/java/com/dbx/agent/CommonJavaCompatibilityTest.java index 1213038fb6..b3ce2acd39 100644 --- a/agents/common/src/test/java/com/dbx/agent/CommonJavaCompatibilityTest.java +++ b/agents/common/src/test/java/com/dbx/agent/CommonJavaCompatibilityTest.java @@ -440,6 +440,30 @@ class CommonJavaCompatibilityTest { assertEquals("order_view", objects.get(0).getName()); } + @Test + void tableCommentPrefersExactNameAndPreservesWhitespace() { + DatabaseAgent agent = new TableCommentAgent(Arrays.asList( + new TableInfo("users", "TABLE", "lowercase comment"), + new TableInfo("Users", "TABLE", " exact comment ") + )); + + assertEquals(" exact comment ", agent.getTableComment("public", "Users")); + } + + @Test + void tableCommentUsesOnlyUniqueCaseInsensitiveFallback() { + DatabaseAgent unique = new TableCommentAgent(Collections.singletonList( + new TableInfo("USERS", "TABLE", " normalized comment ") + )); + DatabaseAgent ambiguous = new TableCommentAgent(Arrays.asList( + new TableInfo("Users", "TABLE", "first"), + new TableInfo("USERS", "TABLE", "second") + )); + + assertEquals(" normalized comment ", unique.getTableComment("public", "users")); + assertEquals(null, ambiguous.getTableComment("public", "users")); + } + @Test void executesTransactionsOneByOneWhenJdbcDriverDoesNotSupportTransactions() { List calls = new ArrayList<>(); @@ -631,6 +655,19 @@ class CommonJavaCompatibilityTest { } } + private static final class TableCommentAgent extends MinimalAgent { + private final List tables; + + private TableCommentAgent(List tables) { + this.tables = tables; + } + + @Override + public List listTables(String schema) { + return tables; + } + } + private static final class TransactionAgent extends MinimalAgent { private final Connection connection; diff --git a/agents/drivers/oceanbase-oracle/src/main/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgent.java b/agents/drivers/oceanbase-oracle/src/main/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgent.java index fce005fd5e..f8339ba119 100644 --- a/agents/drivers/oceanbase-oracle/src/main/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgent.java +++ b/agents/drivers/oceanbase-oracle/src/main/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgent.java @@ -364,7 +364,33 @@ public final class OceanBaseOracleAgent extends ConfiguredJdbcAgent { foreignKeys = Collections.emptyList(); } - return DdlBuilder.buildTableDdl(schema, table, getColumns(schema, table), indexes, foreignKeys, false, true); + String tableComment = null; + try { + tableComment = getTableComment(schema, table); + } catch (RuntimeException e) { + // Table comment is optional; DDL generation should still succeed without it. + } + + return DdlBuilder.buildTableDdl(schema, table, getColumns(schema, table), indexes, foreignKeys, java.util.Collections.emptyList(), false, true, tableComment); + } + + @Override + public String getTableComment(String schema, String table) { + return unchecked(() -> { + String owner = normalizeSchema(schema); + String sql = "SELECT COMMENTS FROM ALL_TAB_COMMENTS WHERE OWNER = ? AND TABLE_NAME = ? AND TABLE_TYPE = 'TABLE'"; + try (var stmt = requireConnection().prepareStatement(sql)) { + stmt.setString(1, owner); + stmt.setString(2, table); + try (var rs = stmt.executeQuery()) { + if (rs.next()) { + String comment = rs.getString("COMMENTS"); + return (comment != null && !comment.trim().isEmpty()) ? comment : null; + } + } + } + return null; + }); } @Override diff --git a/agents/drivers/oceanbase-oracle/src/test/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgentTest.java b/agents/drivers/oceanbase-oracle/src/test/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgentTest.java index 0530b5ca72..eb3b9e1dd0 100644 --- a/agents/drivers/oceanbase-oracle/src/test/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgentTest.java +++ b/agents/drivers/oceanbase-oracle/src/test/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgentTest.java @@ -197,6 +197,10 @@ class OceanBaseOracleAgentTest { new String[]{"CONSTRAINT_NAME", "COLUMN_NAME", "TABLE_NAME", "REF_COLUMN_NAME"}, new Object[][]{} ), + resultSet( + new String[]{"COMMENTS"}, + new Object[][]{{null}} + ), columnResultSet(new Object[][]{ {"CREATED_AT", "TIMESTAMP", "N", null, null, null, null, "SYSDATE", "Created timestamp", 0}, {"INTERNAL_NOTE", "VARCHAR2", "Y", null, null, 100, 100, null, " ", 0} diff --git a/agents/drivers/sqlserver-legacy/src/main/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgent.java b/agents/drivers/sqlserver-legacy/src/main/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgent.java index 842da3201b..2a8b7285c6 100644 --- a/agents/drivers/sqlserver-legacy/src/main/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgent.java +++ b/agents/drivers/sqlserver-legacy/src/main/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgent.java @@ -2,6 +2,9 @@ package com.dbx.agent.sqlserverlegacy; import com.dbx.agent.ConfiguredJdbcAgent; import com.dbx.agent.ConnectParams; +import com.dbx.agent.DdlBuilder; +import com.dbx.agent.ForeignKeyInfo; +import com.dbx.agent.IndexInfo; import com.dbx.agent.JdbcAgentProfile; import com.dbx.agent.MultiSessionJsonRpcServer; @@ -9,9 +12,12 @@ import java.security.Security; import java.sql.Connection; import java.sql.Driver; import java.sql.DriverManager; +import java.sql.PreparedStatement; +import java.sql.ResultSet; import java.sql.SQLException; import java.util.ArrayList; import java.util.Arrays; +import java.util.Collections; import java.util.LinkedHashMap; import java.util.List; import java.util.Locale; @@ -68,6 +74,83 @@ public final class SqlServerLegacyAgent extends ConfiguredJdbcAgent { } } + @Override + public String getTableComment(String schema, String table) { + return unchecked(() -> { + try (PreparedStatement statement = requireConnection().prepareStatement(tableCommentSql())) { + statement.setString(1, schema); + statement.setString(2, table); + try (ResultSet resultSet = statement.executeQuery()) { + if (resultSet.next()) { + String comment = resultSet.getString("table_comment"); + return comment != null && !comment.trim().isEmpty() ? comment : null; + } + } + } + return null; + }); + } + + @Override + public String getTableDdl(String schema, String table) { + List indexes; + try { + indexes = listIndexes(schema, table); + } catch (RuntimeException error) { + indexes = Collections.emptyList(); + } + + List foreignKeys; + try { + foreignKeys = listForeignKeys(schema, table); + } catch (RuntimeException error) { + foreignKeys = Collections.emptyList(); + } + + String tableComment = null; + try { + tableComment = getTableComment(schema, table); + } catch (RuntimeException error) { + // Extended properties are optional; base DDL must remain available. + } + + String ddl = DdlBuilder.buildTableDdl( + schema, + table, + getColumns(schema, table), + indexes, + foreignKeys, + Collections.emptyList(), + false, + false, + null + ); + return appendTableCommentDdl(ddl, schema, table, tableComment); + } + + static String tableCommentSql() { + return "SELECT CAST(ep.value AS nvarchar(max)) AS table_comment " + + "FROM sys.extended_properties ep " + + "JOIN sys.tables t ON t.object_id = ep.major_id " + + "JOIN sys.schemas s ON s.schema_id = t.schema_id " + + "WHERE ep.class = 1 AND ep.minor_id = 0 AND ep.name = N'MS_Description' " + + "AND s.name = ? AND t.name = ?"; + } + + static String appendTableCommentDdl(String ddl, String schema, String table, String comment) { + if (comment == null || comment.trim().isEmpty()) { + return ddl; + } + return ddl + + "\nEXEC sys.sp_addextendedproperty @name=N'MS_Description', @value=" + sqlServerString(comment) + + ", @level0type=N'SCHEMA', @level0name=" + sqlServerString(schema) + + ", @level1type=N'TABLE', @level1name=" + sqlServerString(table) + ";"; + } + + private static String sqlServerString(String value) { + return "N'" + value.replace("'", "''") + "'"; + } + static String legacyTlsUrl(ConnectParams params) { Map properties = baseConnectionProperties(params); properties.put("encrypt", "true"); diff --git a/agents/drivers/sqlserver-legacy/src/test/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgentTest.java b/agents/drivers/sqlserver-legacy/src/test/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgentTest.java index 2f3249fb45..3cbd5d61cd 100644 --- a/agents/drivers/sqlserver-legacy/src/test/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgentTest.java +++ b/agents/drivers/sqlserver-legacy/src/test/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgentTest.java @@ -108,4 +108,39 @@ class SqlServerLegacyAgentTest { SqlServerLegacyAgent.relaxedDisabledAlgorithms(current) ); } + + @Test + void tableCommentQueryReadsSqlServerExtendedProperty() { + String sql = SqlServerLegacyAgent.tableCommentSql(); + + Assertions.assertTrue(sql.contains("sys.extended_properties")); + Assertions.assertTrue(sql.contains("ep.minor_id = 0")); + Assertions.assertTrue(sql.contains("ep.name = N'MS_Description'")); + Assertions.assertTrue(sql.contains("s.name = ? AND t.name = ?")); + } + + @Test + void tableCommentDdlUsesExtendedPropertyAndPreservesWhitespace() { + String ddl = SqlServerLegacyAgent.appendTableCommentDdl( + "CREATE TABLE [dbo].[Users] ([id] int);\n", + "dbo", + "Users", + " Owner's table " + ); + + Assertions.assertTrue(ddl.contains("EXEC sys.sp_addextendedproperty")); + Assertions.assertTrue(ddl.contains("@value=N' Owner''s table '")); + Assertions.assertTrue(ddl.contains("@level0name=N'dbo'")); + Assertions.assertTrue(ddl.contains("@level1name=N'Users'")); + } + + @Test + void tableCommentDdlIgnoresWhitespaceOnlyComment() { + String baseDdl = "CREATE TABLE [dbo].[Users] ([id] int);\n"; + + Assertions.assertEquals( + baseDdl, + SqlServerLegacyAgent.appendTableCommentDdl(baseDdl, "dbo", "Users", " ") + ); + } } diff --git a/crates/dbx-core/src/schema.rs b/crates/dbx-core/src/schema.rs index 96e5a5ee8c..5e19fe7607 100644 --- a/crates/dbx-core/src/schema.rs +++ b/crates/dbx-core/src/schema.rs @@ -5837,11 +5837,38 @@ mod ddl_tests { display_name.comment = Some("User's display name".to_string()); let columns = vec![display_name]; - let ddl = render_postgres_table_ddl("public", "users", &columns, &[], &[]); + let ddl = render_postgres_table_ddl("public", "users", &columns, &[], &[], None); assert!(ddl.contains("COMMENT ON COLUMN \"public\".\"users\".\"display_name\" IS 'User''s display name';")); } + #[test] + fn postgres_table_ddl_includes_table_comment() { + let columns = vec![column("id", "integer")]; + + let ddl = render_postgres_table_ddl("public", "users", &columns, &[], &[], Some("User table")); + + assert!(ddl.contains("COMMENT ON TABLE \"public\".\"users\" IS 'User table';")); + } + + #[test] + fn postgres_table_ddl_omits_table_comment_when_empty() { + let columns = vec![column("id", "integer")]; + + let ddl = render_postgres_table_ddl("public", "users", &columns, &[], &[], Some("")); + + assert!(!ddl.contains("COMMENT ON TABLE")); + } + + #[test] + fn postgres_table_ddl_preserves_table_comment_whitespace() { + let columns = vec![column("id", "integer")]; + + let ddl = render_postgres_table_ddl("public", "users", &columns, &[], &[], Some(" User table ")); + + assert!(ddl.contains("COMMENT ON TABLE \"public\".\"users\" IS ' User table ';")); + } + #[test] fn postgres_table_ddl_includes_generated_identity() { let mut id = column("id", "integer"); @@ -5849,7 +5876,7 @@ mod ddl_tests { id.is_primary_key = true; id.extra = Some("generated by default as identity".to_string()); - let ddl = render_postgres_table_ddl("public", "users", &[id], &[], &[]); + let ddl = render_postgres_table_ddl("public", "users", &[id], &[], &[], None); assert!(ddl.contains("\"id\" integer generated by default as identity NOT NULL"), "ddl: {ddl}"); } @@ -5887,7 +5914,7 @@ mod ddl_tests { }, ]; - let ddl = render_postgres_table_ddl("public", "aaa_1", &columns, &[], &foreign_keys); + let ddl = render_postgres_table_ddl("public", "aaa_1", &columns, &[], &foreign_keys, None); assert!(ddl.contains( "CONSTRAINT \"aaa_1\" FOREIGN KEY (\"a\", \"b\", \"c\") REFERENCES \"aaa_2\"(\"a\", \"b\", \"c\")" @@ -5901,7 +5928,7 @@ mod ddl_tests { display_name.comment = Some("User's display name".to_string()); let columns = vec![display_name]; - let ddl = render_sqlserver_table_ddl("dbo", "users", &columns, &[], &[]); + let ddl = render_sqlserver_table_ddl("dbo", "users", &columns, &[], &[], None); assert!(ddl.contains("CREATE TABLE [dbo].[users] (\n [display]]name] nvarchar(100)\n);")); assert!(ddl.contains( @@ -5909,6 +5936,35 @@ mod ddl_tests { )); } + #[test] + fn sqlserver_table_ddl_includes_table_comment() { + let columns = vec![column("id", "int")]; + + let ddl = render_sqlserver_table_ddl("dbo", "users", &columns, &[], &[], Some("User table")); + + assert!(ddl.contains( + "EXEC sys.sp_addextendedproperty @name=N'MS_Description', @value=N'User table', @level0type=N'SCHEMA', @level0name=N'dbo', @level1type=N'TABLE', @level1name=N'users';" + )); + } + + #[test] + fn sqlserver_table_ddl_omits_table_comment_when_empty() { + let columns = vec![column("id", "int")]; + + let ddl = render_sqlserver_table_ddl("dbo", "users", &columns, &[], &[], Some("")); + + assert!(!ddl.contains("MS_Description")); + } + + #[test] + fn sqlserver_table_ddl_preserves_table_comment_whitespace() { + let columns = vec![column("id", "int")]; + + let ddl = render_sqlserver_table_ddl("dbo", "users", &columns, &[], &[], Some(" User table ")); + + assert!(ddl.contains("@value=N' User table '")); + } + #[test] fn sqlserver_table_ddl_includes_identity_clause() { let mut id = column("FIDS", "int"); @@ -5916,7 +5972,7 @@ mod ddl_tests { id.is_primary_key = true; id.extra = Some("identity(1,1)".to_string()); - let ddl = render_sqlserver_table_ddl("dbo", "ZHLSBS", &[id], &[], &[]); + let ddl = render_sqlserver_table_ddl("dbo", "ZHLSBS", &[id], &[], &[], None); assert!(ddl.contains("[FIDS] int IDENTITY(1,1) NOT NULL"), "ddl: {ddl}"); } @@ -6007,13 +6063,14 @@ pub fn opengauss_table_ddl_sql(schema: &str, table: &str) -> String { } pub async fn pg_ddl(pool: &deadpool_postgres::Pool, schema: &str, table: &str) -> Result { - let (columns, indexes, fkeys) = tokio::try_join!( + let (columns, indexes, fkeys, table_comment) = 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 }, )?; - Ok(render_postgres_table_ddl(schema, table, &columns, &indexes, &fkeys)) + Ok(render_postgres_table_ddl(schema, table, &columns, &indexes, &fkeys, table_comment.as_deref())) } pub fn render_postgres_table_ddl( @@ -6022,6 +6079,7 @@ pub fn render_postgres_table_ddl( columns: &[db::ColumnInfo], indexes: &[db::IndexInfo], fkeys: &[db::ForeignKeyInfo], + table_comment: Option<&str>, ) -> String { let table_name = format!("{}.{}", pg_ident(schema), pg_ident(table)); let mut ddl = format!("CREATE TABLE {table_name} (\n"); @@ -6070,6 +6128,10 @@ pub fn render_postgres_table_ddl( } ddl.push_str("\n);\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))); + } + for col in columns { if let Some(comment) = col.comment.as_deref().filter(|comment| !comment.is_empty()) { ddl.push_str(&format!( @@ -6147,8 +6209,9 @@ pub async fn build_sqlserver_ddl( let columns = db::sqlserver::get_columns(client, schema, table).await?; let indexes = db::sqlserver::list_indexes(client, schema, table).await?; let fkeys = db::sqlserver::list_foreign_keys(client, schema, table).await?; + let table_comment = db::sqlserver::get_table_comment(client, schema, table).await?; - Ok(render_sqlserver_table_ddl(schema, table, &columns, &indexes, &fkeys)) + Ok(render_sqlserver_table_ddl(schema, table, &columns, &indexes, &fkeys, table_comment.as_deref())) } pub fn render_sqlserver_table_ddl( @@ -6157,6 +6220,7 @@ pub fn render_sqlserver_table_ddl( columns: &[db::ColumnInfo], indexes: &[db::IndexInfo], fkeys: &[db::ForeignKeyInfo], + table_comment: Option<&str>, ) -> String { let table_name = format!("{}.{}", sqlserver_ident(schema), sqlserver_ident(table)); let mut ddl = format!("CREATE TABLE {table_name} (\n"); @@ -6196,6 +6260,15 @@ pub fn render_sqlserver_table_ddl( } ddl.push_str("\n);\n"); + if let Some(comment) = table_comment.filter(|comment| !comment.trim().is_empty()) { + ddl.push_str(&format!( + "\nEXEC sys.sp_addextendedproperty @name=N'MS_Description', @value={}, @level0type=N'SCHEMA', @level0name={}, @level1type=N'TABLE', @level1name={};", + sqlserver_n_string(comment), + sqlserver_n_string(schema), + sqlserver_n_string(table) + )); + } + for column in columns { if let Some(comment) = column.comment.as_deref().map(str::trim).filter(|comment| !comment.is_empty()) { ddl.push_str(&format!( diff --git a/crates/dbx-core/src/transfer.rs b/crates/dbx-core/src/transfer.rs index 46ca515cbb..e4436133c6 100644 --- a/crates/dbx-core/src/transfer.rs +++ b/crates/dbx-core/src/transfer.rs @@ -5793,7 +5793,7 @@ mod tests { ..Default::default() }, ]; - let source_ddl = crate::schema::render_postgres_table_ddl("public", "it_quick_entry", &columns, &[], &[]); + let source_ddl = crate::schema::render_postgres_table_ddl("public", "it_quick_entry", &columns, &[], &[], None); let rewritten = rewrite_transfer_source_table_ddl( &source_ddl, "public",