25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
fix(oracle): include dictionary comments in table and view DDL
Mo-Mooree00fbabb3534
diff --git a/agents/drivers/oracle-go/main.go b/agents/drivers/oracle-go/main.goindex 9802f64172..e003a37b3f 100644--- a/agents/drivers/oracle-go/main.go+++ b/agents/drivers/oracle-go/main.go@@ -3389,10 +3389,64 @@ func (s *server) buildViewDDL(schema, name string) (string, error) {}trimmed := strings.TrimSpace(source)upperSource := strings.ToUpper(trimmed)+ var ddl stringif strings.HasPrefix(upperSource, "CREATE ") || strings.HasPrefix(upperSource, "ALTER ") {- return trimmed, nil+ ddl = trimmed+ } else {+ ddl = fmt.Sprintf("CREATE OR REPLACE VIEW %s.%s AS\n%s", quoteIdentifier(schema), quoteIdentifier(name), trimmed)+ }+ return s.appendViewCommentDDLs(schema, name, ddl), nil+}++// appendViewCommentDDLs appends COMMENT ON TABLE/COLUMN statements for views.+// Oracle stores view comments in ALL_TAB_COMMENTS / ALL_COL_COMMENTS the same way as tables.+func (s *server) appendViewCommentDDLs(schema, name, viewDDL string) string {+ comments, err := s.loadTableCommentDDLs(schema, name)+ if err != nil || len(comments) == 0 {+ return viewDDL+ }+ var builder strings.Builder+ builder.WriteString(terminateOracleViewDDL(strings.TrimSpace(viewDDL)))+ for _, comment := range comments {+ appendOracleDDLFragment(&builder, comment)+ }+ return builder.String()+}++func terminateOracleViewDDL(ddl string) string {+ var lastCode byte+ trailingLineComment := false+ for pos := 0; pos < len(ddl); pos++ {+ if isSQLWhitespace(ddl[pos]) {+ continue+ }+ if ddl[pos] == '-' && pos+1 < len(ddl) && ddl[pos+1] == '-' {+ pos = skipLineCommentSQL(ddl, pos)+ trailingLineComment = true+ continue+ }+ if ddl[pos] == '/' && pos+1 < len(ddl) && ddl[pos+1] == '*' {+ pos = skipBlockCommentSQL(ddl, pos)+ trailingLineComment = false+ continue+ }+ if end, ok := skipOracleAlternativeQuotedSQL(ddl, pos); ok {+ pos = end+ } else if ddl[pos] == '\'' {+ pos = skipSingleQuotedSQL(ddl, pos)+ } else if ddl[pos] == '"' {+ pos = skipDoubleQuotedSQL(ddl, pos)+ }+ lastCode = ddl[pos]+ trailingLineComment = false+ }+ if lastCode == ';' || lastCode == '/' {+ return ddl+ }+ if trailingLineComment {+ return ddl + "\n;"}- return fmt.Sprintf("CREATE OR REPLACE VIEW %s.%s AS\n%s", quoteIdentifier(schema), quoteIdentifier(name), trimmed), nil+ return ddl + ";"}func (s *server) getViewSource(schema, name string) (string, error) {diff --git a/agents/drivers/oracle-go/main_test.go b/agents/drivers/oracle-go/main_test.goindex 5c3668fc2f..31e8c5607e 100644--- a/agents/drivers/oracle-go/main_test.go+++ b/agents/drivers/oracle-go/main_test.go@@ -629,6 +629,189 @@ func TestGetTableDDLAppendsIndexesTriggersAndComments(t *testing.T) {}}+func TestBuildViewDDLAppendsComments(t *testing.T) {+ const schema = "HR"+ const view = "ACTIVE_ORDERS"+ const viewText = `SELECT "ID", "STATUS" FROM "HR"."ORDERS" WHERE "STATUS" = 'OPEN'`+ db, scripted := openOracleViewSourceTestDB(t, []oracleViewSourceQueryStep{+ {+ queryContains: "FROM ALL_VIEWS",+ args: []driver.Value{schema, view},+ rows: [][]driver.Value{{viewText}},+ },+ {+ queryContains: "FROM ALL_TAB_COMMENTS",+ args: []driver.Value{schema, view},+ rows: [][]driver.Value{{"Open orders view"}},+ },+ {+ queryContains: "FROM ALL_COL_COMMENTS",+ args: []driver.Value{schema, view},+ columns: []string{"COLUMN_NAME", "COMMENTS"},+ rows: [][]driver.Value{{"STATUS", "Order status"}},+ },+ })+ s := newServer()+ s.db = db++ got, err := s.buildViewDDL(schema, view)+ if err != nil {+ t.Fatal(err)+ }+ for _, fragment := range []string{+ `CREATE OR REPLACE VIEW "HR"."ACTIVE_ORDERS" AS`,+ viewText,+ `COMMENT ON TABLE "HR"."ACTIVE_ORDERS" IS 'Open orders view';`,+ `COMMENT ON COLUMN "HR"."ACTIVE_ORDERS"."STATUS" IS 'Order status';`,+ } {+ if !strings.Contains(got, fragment) {+ t.Fatalf("buildViewDDL() missing %q:\n%s", fragment, got)+ }+ }+ if !strings.Contains(got, viewText+";\n\nCOMMENT ON TABLE") {+ t.Fatalf("view DDL should be terminated before comment DDL:\n%s", got)+ }+ if scripted.next != len(scripted.steps) {+ t.Fatalf("expected %d queries, got %d", len(scripted.steps), scripted.next)+ }+}++func TestBuildViewDDLCommentBoundaries(t *testing.T) {+ const query = `SELECT 1 AS "ID" FROM DUAL`+ for _, test := range []struct {+ name string+ source string+ terminated string+ noComments bool+ tableError bool+ columnError bool+ columnOnly bool+ tableOnly bool+ metadataFallback bool+ }{+ {name: "plain", source: query, terminated: query + ";"},+ {name: "line comment", source: query + " -- trailing", terminated: query + " -- trailing\n;"},+ {name: "semicolon in comment", source: query + " -- trailing;", terminated: query + " -- trailing;\n;"},+ {name: "slash in comment", source: query + " -- trailing /", terminated: query + " -- trailing /\n;"},+ {name: "existing terminator", source: query + ";", terminated: query + ";"},+ {name: "slash delimiter", source: query + "\n/", terminated: query + "\n/"},+ {name: "terminated before line comment", source: query + "; -- trailing;", terminated: query + "; -- trailing;"},+ {name: "terminated before block comment", source: query + "; /* trailing; */", terminated: query + "; /* trailing; */"},+ {name: "block comment", source: query + " /* trailing; */", terminated: query + " /* trailing; */;"},+ {name: "quoted comment markers", source: `SELECT '--;', q'[owner's --;]' AS "--ID" FROM DUAL -- tail`, terminated: `SELECT '--;', q'[owner's --;]' AS "--ID" FROM DUAL -- tail` + "\n;"},+ {name: "full create", source: `CREATE VIEW "HR"."ACTIVE_ORDERS" AS ` + query + " -- tail", terminated: `CREATE VIEW "HR"."ACTIVE_ORDERS" AS ` + query + " -- tail\n;"},+ {name: "metadata fallback", source: `CREATE VIEW "HR"."ACTIVE_ORDERS" AS ` + query + " -- tail;", terminated: `CREATE VIEW "HR"."ACTIVE_ORDERS" AS ` + query + " -- tail;\n;", metadataFallback: true},+ {name: "column only", source: query + " -- tail;", terminated: query + " -- tail;\n;", columnOnly: true},+ {name: "table only", source: query + " -- tail;", terminated: query + " -- tail;\n;", tableOnly: true},+ {name: "no comments", source: query, noComments: true},+ {name: "no comments with trailing comment", source: query + " -- tail;\n", noComments: true},+ {name: "table lookup failure", source: query + " -- tail", tableError: true},+ {name: "column lookup failure", source: query + " -- tail", columnError: true},+ } {+ t.Run(test.name, func(t *testing.T) {+ tableStep := oracleViewSourceQueryStep{queryContains: "FROM ALL_TAB_COMMENTS", args: []driver.Value{"HR", "ACTIVE_ORDERS"}}+ columnStep := oracleViewSourceQueryStep{queryContains: "FROM ALL_COL_COMMENTS", args: []driver.Value{"HR", "ACTIVE_ORDERS"}, columns: []string{"COLUMN_NAME", "COMMENTS"}}+ if !test.noComments {+ if !test.columnOnly {+ tableStep.rows = [][]driver.Value{{"View's comment"}}+ }+ if !test.tableOnly {+ columnStep.rows = [][]driver.Value{{"ID", "Column's comment"}}+ }+ }+ if test.tableError {+ tableStep.err = errors.New("dictionary denied")+ }+ if test.columnError {+ columnStep.err = errors.New("dictionary denied")+ }+ steps := []oracleViewSourceQueryStep{+ {queryContains: "FROM ALL_VIEWS", args: []driver.Value{"HR", "ACTIVE_ORDERS"}, rows: [][]driver.Value{{test.source}}},+ }+ if test.metadataFallback {+ steps[0].err = errors.New("view text unavailable")+ steps = append(steps, oracleViewSourceQueryStep{+ queryContains: "DBMS_METADATA.GET_DDL('VIEW'", args: []driver.Value{"ACTIVE_ORDERS", "HR"}, rows: [][]driver.Value{{test.source}},+ })+ }+ steps = append(steps, tableStep)+ if !test.tableError {+ steps = append(steps, columnStep)+ }+ database, scripted := openOracleViewSourceTestDB(t, steps)+ server := newServer()+ server.db = database+ got, err := server.buildViewDDL("HR", "ACTIVE_ORDERS")+ if err != nil {+ t.Fatal(err)+ }+ want := test.terminated+ if test.noComments || test.tableError || test.columnError {+ want = strings.TrimSpace(test.source)+ } else {+ if !test.columnOnly {+ want += "\n\nCOMMENT ON TABLE \"HR\".\"ACTIVE_ORDERS\" IS 'View''s comment';"+ }+ if !test.tableOnly {+ want += "\n\nCOMMENT ON COLUMN \"HR\".\"ACTIVE_ORDERS\".\"ID\" IS 'Column''s comment';"+ }+ }+ if !strings.HasPrefix(want, "CREATE ") {+ want = "CREATE OR REPLACE VIEW \"HR\".\"ACTIVE_ORDERS\" AS\n" + want+ }+ if got != want {+ t.Fatalf("buildViewDDL() = %q, want %q", got, want)+ }+ if scripted.next != len(scripted.steps) {+ t.Fatalf("expected %d queries, got %d", len(scripted.steps), scripted.next)+ }+ })+ }+}++func TestGetTableDDLForViewAppendsComments(t *testing.T) {+ const schema = "HR"+ const view = "ACTIVE_ORDERS"+ const viewText = `SELECT 1 AS "ID" FROM DUAL`+ db, scripted := openOracleViewSourceTestDB(t, []oracleViewSourceQueryStep{+ {+ queryContains: "FROM ALL_VIEWS",+ args: []driver.Value{schema, view},+ rows: [][]driver.Value{{viewText}},+ },+ {+ queryContains: "FROM ALL_TAB_COMMENTS",+ args: []driver.Value{schema, view},+ rows: [][]driver.Value{{"Active orders"}},+ },+ {+ queryContains: "FROM ALL_COL_COMMENTS",+ args: []driver.Value{schema, view},+ columns: []string{"COLUMN_NAME", "COMMENTS"},+ rows: [][]driver.Value{{"ID", "Row id"}},+ },+ })+ s := newServer()+ s.db = db++ got, err := s.getTableDDL(schema, view, "VIEW")+ if err != nil {+ t.Fatal(err)+ }+ if !strings.Contains(got, `CREATE OR REPLACE VIEW "HR"."ACTIVE_ORDERS" AS`) {+ t.Fatalf("expected view create DDL, got:\n%s", got)+ }+ if !strings.Contains(got, `COMMENT ON TABLE "HR"."ACTIVE_ORDERS" IS 'Active orders';`) {+ t.Fatalf("expected view table comment, got:\n%s", got)+ }+ if !strings.Contains(got, `COMMENT ON COLUMN "HR"."ACTIVE_ORDERS"."ID" IS 'Row id';`) {+ t.Fatalf("expected view column comment, got:\n%s", got)+ }+ if scripted.next != len(scripted.steps) {+ t.Fatalf("expected %d queries, got %d", len(scripted.steps), scripted.next)+ }+}+func TestGetPortableTableDDLDisablesAndRestoresSegmentAttributes(t *testing.T) {const schema = "HR"const table = "ORDERS"diff --git a/crates/dbx-core/src/object_source_sql.rs b/crates/dbx-core/src/object_source_sql.rsindex 1f2a464559..fb7cb144ff 100644--- a/crates/dbx-core/src/object_source_sql.rs+++ b/crates/dbx-core/src/object_source_sql.rs@@ -1,5 +1,7 @@use regex::Regex;use serde::{Deserialize, Serialize};+use sqlparser::dialect::OracleDialect;+use sqlparser::tokenizer::{Token, Tokenizer, Whitespace};use crate::models::connection::DatabaseType;use crate::types::ObjectSourceKind;@@ -225,8 +227,16 @@ pub fn build_editable_object_source(input: EditableObjectSourceSqlInput) -> Stripub fn build_view_ddl_sql(input: BuildViewDdlInput) -> String {let source = input.source.trim();+ let terminated_source = if matches!(+ input.database_type,+ Some(DatabaseType::Oracle | DatabaseType::OceanbaseOracle | DatabaseType::Dameng)+ ) {+ ensure_oracle_ddl_terminated(source)+ } else {+ ensure_semicolon(source)+ };if Regex::new(r"(?i)^(?:CREATE|ALTER)\s+").unwrap().is_match(source) {- return ensure_semicolon(source);+ return terminated_source;}// Backtick-quoting is used for MySQL-family engines and for connections@@ -248,10 +258,10 @@ pub fn build_view_ddl_sql(input: BuildViewDdlInput) -> String {|| database_type == DatabaseType::Questdb}){- return format!("CREATE OR REPLACE VIEW {qualified_name} AS\n{}", ensure_semicolon(source));+ return format!("CREATE OR REPLACE VIEW {qualified_name} AS\n{terminated_source}");}- format!("CREATE VIEW {qualified_name} AS\n{}", ensure_semicolon(source))+ format!("CREATE VIEW {qualified_name} AS\n{terminated_source}")}pub fn build_export_object_source_sql(@@ -366,6 +376,23 @@ fn quote_mysql_identifier(value: &str) -> String {format!("`{}`", value.replace('`', "``"))}+pub(crate) fn ensure_oracle_ddl_terminated(sql: &str) -> String {+ let trimmed = sql.trim_end();+ if trimmed.trim().is_empty() {+ return String::new();+ }+ if let Ok(tokens) = Tokenizer::new(&OracleDialect {}, trimmed).tokenize() {+ let last_code = tokens.iter().rev().find(|token| !matches!(token, Token::Whitespace(_)));+ if matches!(last_code, Some(Token::SemiColon | Token::Div)) {+ return trimmed.to_string();+ }+ if !matches!(tokens.last(), Some(Token::Whitespace(Whitespace::SingleLineComment { .. }))) {+ return format!("{trimmed};");+ }+ }+ format!("{trimmed}\n;")+}+fn ensure_semicolon(sql: &str) -> String {let trimmed = sql.trim();if trimmed.ends_with(';') {@@ -967,6 +994,22 @@ fn parse_object_source_kind(value: &str) -> Option<ObjectSourceKind> {mod tests {use super::*;+ #[test]+ fn oracle_ddl_terminator_respects_quoted_tokens_and_slash_delimiters() {+ for (source, expected) in [+ ("SELECT q'[owner's --;]' FROM DUAL -- tail;", "SELECT q'[owner's --;]' FROM DUAL -- tail;\n;"),+ ("SELECT q'[owner's --;]' FROM DUAL; -- tail;", "SELECT q'[owner's --;]' FROM DUAL; -- tail;"),+ ("SELECT 1 AS \"名--称\" FROM DUAL -- tail;", "SELECT 1 AS \"名--称\" FROM DUAL -- tail;\n;"),+ ("SELECT 1 FROM DUAL\n/", "SELECT 1 FROM DUAL\n/"),+ ("SELECT 1 FROM DUAL;\n/", "SELECT 1 FROM DUAL;\n/"),+ ("SELECT 1 FROM DUAL\n/\n-- tail;", "SELECT 1 FROM DUAL\n/\n-- tail;"),+ (" CREATE TABLE t (id NUMBER);\n", " CREATE TABLE t (id NUMBER);"),+ (" \n", ""),+ ] {+ assert_eq!(ensure_oracle_ddl_terminated(source), expected);+ }+ }+fn input(database_type: DatabaseType, object_type: ObjectSourceKind, source: &str) -> EditableObjectSourceSqlInput {EditableObjectSourceSqlInput {database_type,diff --git a/crates/dbx-core/src/schema.rs b/crates/dbx-core/src/schema.rsindex c6d6505113..49dd37c3de 100644--- a/crates/dbx-core/src/schema.rs+++ b/crates/dbx-core/src/schema.rs@@ -1232,6 +1232,18 @@ async fn get_table_comment_core_for_session({let pool_handle = state.pool_handle(&pool_key).await;try_sqlserver!(pool_handle, get_table_comment, schema, table);+ if let Some(PoolKind::ExternalDriver { config, session, .. }) = pool_handle.as_ref() {+ if is_oracle_external_driver_config(config.as_ref()) {+ return external_driver_oracle_table_comment(+ session.clone(),+ config.as_ref(),+ database,+ schema,+ table,+ )+ .await;+ }+ }if let Some(client) = extract_pool!(pool_handle.as_ref(), Agent) {if db_config.as_ref().is_some_and(|config| {matches!(config.db_type, DatabaseType::Oracle | DatabaseType::OceanbaseOracle)@@ -3180,12 +3192,12 @@ mod tests {presto_like_columns_from_query_result, presto_like_information_schema_columns_sql,presto_like_information_schema_tables_sql, presto_like_tables_from_query_result,reference_key_columns_from_indexes, reference_keys_from_indexes, replace_metadata_runtime,- should_query_oracle_columns_via_sql_first, table_comments_from_query_result, table_name_filter_matches,- tdengine_table_comment_like_pattern, tdengine_table_comment_sql, tdengine_table_comments_sql,- uses_mongodb_agent_collection_listing, visible_schema_filter, ExternalDriverStatisticsDialect,- MetadataErrorAction, MysqlTableListSource, OracleObjectRef, OracleSynonymResolver, ReferenceKeyInfo,- TableNameFilter, ORACLE_CURRENT_SCHEMA_SQL, ORACLE_SYNONYM_MAX_DEPTH, TDENGINE_COMMENT_SEARCH_TIMEOUT,- TDENGINE_LIKE_PATTERN_MAX_BYTES,+ should_append_oracle_style_comment_ddl, should_query_oracle_columns_via_sql_first,+ table_comments_from_query_result, table_name_filter_matches, tdengine_table_comment_like_pattern,+ tdengine_table_comment_sql, tdengine_table_comments_sql, uses_mongodb_agent_collection_listing,+ visible_schema_filter, ExternalDriverStatisticsDialect, MetadataErrorAction, MysqlTableListSource,+ OracleObjectRef, OracleSynonymResolver, ReferenceKeyInfo, TableNameFilter, ORACLE_CURRENT_SCHEMA_SQL,+ ORACLE_SYNONYM_MAX_DEPTH, TDENGINE_COMMENT_SEARCH_TIMEOUT, TDENGINE_LIKE_PATTERN_MAX_BYTES,};use super::{list_databases_core, list_tables_core};use super::{@@ -3709,6 +3721,270 @@ doneassert!(!is_oracle_external_driver_config(&config));}+ #[cfg(unix)]+ mod oracle_ddl_regression_tests {+ use super::*;+ use crate::types::ObjectSourceKind;+ use serde_json::{json, Value};+ use std::os::unix::fs::PermissionsExt;+ use std::path::PathBuf;++ async fn scripted_oracle_driver(source: Value, columns: Value, comment: Value) -> (AppState, PathBuf) {+ let dir = std::env::temp_dir().join(format!("dbx-oracle-ddl-test-{}", uuid::Uuid::new_v4()));+ std::fs::create_dir_all(&dir).unwrap();+ for (method, response) in [("getObjectSource", source), ("getColumns", columns), ("executeQuery", comment)]+ {+ std::fs::write(dir.join(format!("{method}.json")), response.to_string()).unwrap();+ }+ let executable = dir.join("plugin.sh");+ std::fs::write(+ &executable,+ r#"#!/bin/sh+base=$(dirname "$0")+while IFS= read -r line; do+ printf '%s\n' "$line" >> "$base/calls.log"+ id=$(printf '%s' "$line" | sed -E 's/.*"id":([0-9]+).*/\1/')+ method=$(printf '%s' "$line" | sed -E 's/.*"method":"([^"]+)".*/\1/')+ case "$method" in+ getObjectSource|getColumns|executeQuery)+ response=$(cat "$base/$method.json")+ printf '%s\n' "$response" | sed 's/^{/{"id":'"$id"',/'+ ;;+ *) printf '{"id":%s,"error":{"message":"unsupported test method"}}\n' "$id" ;;+ esac+done+"#,+ )+ .unwrap();+ std::fs::set_permissions(&executable, std::fs::Permissions::from_mode(0o755)).unwrap();+ let plugin = InstalledPlugin {+ manifest: PluginManifest {+ id: "jdbc".into(),+ name: "JDBC".into(),+ version: "test".into(),+ protocol_version: 1,+ executable: Some("plugin.sh".into()),+ drivers: vec![PluginDriverManifest {+ id: "jdbc".into(),+ label: "JDBC".into(),+ kind: "external".into(),+ database_type: Some("jdbc".into()),+ }],+ ..Default::default()+ },+ path: dir.clone(),+ compatibility: crate::plugins::PluginCompatibility {+ compatible: true,+ backend_executable: Some(executable),+ ..Default::default()+ },+ };+ let session = std::sync::Arc::new(+ PluginDriverSession::start_for_test(plugin, "jdbc".into(), PluginRuntimeEnv::default()).await.unwrap(),+ );+ let state = AppState::new(Storage::open(&dir.join("storage.db")).await.unwrap());+ let mut config = test_connection_config(DatabaseType::Jdbc);+ config.id = "oracle-ddl".into();+ config.database = Some("demo".into());+ config.connection_string = Some("jdbc:oracle:thin:@127.0.0.1:1521/demo".into());+ config.jdbc_driver_class = Some("oracle.jdbc.OracleDriver".into());+ state.configs.write().await.insert(config.id.clone(), config.clone());+ state+ .update_connection_pools(|connections| {+ connections.insert(+ config.id.clone(),+ PoolKind::ExternalDriver {+ driver_id: "jdbc".into(),+ config: std::sync::Arc::new(config),+ session,+ },+ );+ })+ .await;+ (state, dir)+ }++ fn column_response() -> Value {+ json!({"result": [db::ColumnInfo {+ name: "ID".into(), comment: Some("Column's comment".into()), ..Default::default()+ }]})+ }++ fn comment_response() -> Value {+ json!({"result": {"columns": ["COMMENTS"], "rows": [["View's comment"]], "affected_rows": 0, "execution_time_ms": 0}})+ }++ fn driver_calls(dir: &std::path::Path) -> Vec<Value> {+ std::fs::read_to_string(dir.join("calls.log"))+ .unwrap()+ .lines()+ .map(|line| serde_json::from_str(line).unwrap())+ .collect()+ }++ #[tokio::test]+ async fn canonical_schema_reaches_queries_and_identifiers() {+ for (requested, returned, expected) in [+ ("hr", Some(json!("HR")), "HR"),+ ("", Some(json!("HR")), "HR"),+ ("mixed_owner", Some(json!("mixed_owner")), "mixed_owner"),+ ("Mixed\"Owner", Some(json!("Mixed\"Owner")), "Mixed\"Owner"),+ ("FallbackOwner", None, "FallbackOwner"),+ ("FallbackOwner", Some(Value::Null), "FallbackOwner"),+ ("FallbackOwner", Some(json!("")), "FallbackOwner"),+ ("FallbackOwner", Some(json!(" ")), "FallbackOwner"),+ ("", None, ""),+ ] {+ for shape in ["table", "view body", "view ddl"] {+ let object_type = (shape != "table").then_some(ObjectSourceKind::View);+ let qualified = if expected.is_empty() {+ "\"ORDERS\"".to_string()+ } else {+ format!("{}.\"ORDERS\"", crate::schema::oracle_ident(expected))+ };+ let source = match shape {+ "table" => format!("CREATE TABLE {qualified} (\"ID\" NUMBER)"),+ "view ddl" => format!("CREATE VIEW {qualified} AS SELECT 1 FROM DUAL -- tail;"),+ _ => "SELECT 1 FROM DUAL -- tail;".to_string(),+ };+ let mut result = json!({"name": "ORDERS", "object_type": if object_type.is_some() { "VIEW" } else { "TABLE" }, "source": source});+ if let Some(returned) = returned.clone() {+ result["schema"] = returned;+ }+ let (state, dir) =+ scripted_oracle_driver(json!({"result": result}), column_response(), comment_response()).await;+ let ddl = crate::schema::get_table_display_ddl_core(+ &state,+ "oracle-ddl",+ "demo",+ requested,+ "ORDERS",+ object_type,+ )+ .await+ .unwrap();+ assert!(+ ddl.starts_with(&format!(+ "CREATE {} {qualified}",+ if shape == "table" { "TABLE" } else { "VIEW" }+ )),+ "{ddl}"+ );+ assert!(ddl.contains(&format!("COMMENT ON TABLE {qualified} IS 'View''s comment';")), "{ddl}");+ assert!(+ ddl.contains(&format!("COMMENT ON COLUMN {qualified}.\"ID\" IS 'Column''s comment';")),+ "{ddl}"+ );+ assert_eq!(+ crate::sql::split_sql_statements_for_database(&ddl, DatabaseType::Oracle).len(),+ 3,+ "{ddl}"+ );+ let calls = driver_calls(&dir);+ let source_call = calls.iter().find(|call| call["method"] == "getObjectSource").unwrap();+ assert_eq!(source_call["params"]["schema"], requested);+ let columns_call = calls.iter().find(|call| call["method"] == "getColumns").unwrap();+ assert_eq!(columns_call["params"]["schema"], expected);+ let comment_call = calls+ .iter()+ .find(|call| call["params"]["sql"].as_str().is_some_and(|sql| sql.contains("ALL_TAB_COMMENTS")))+ .unwrap();+ assert_eq!(comment_call["params"]["schema"], expected);+ assert_eq!(+ comment_call["params"]["sql"],+ crate::schema::oracle_table_comment_sql(expected, "ORDERS")+ );+ state.shutdown(Duration::from_secs(1)).await;+ std::fs::remove_dir_all(dir).unwrap();+ }+ }+ }++ #[tokio::test]+ async fn optional_metadata_failures_preserve_source_and_available_comments() {+ let error = json!({"error": {"message": "dictionary denied"}});+ for (columns, comment, comment_count) in [+ (+ json!({"result": []}),+ json!({"result": {"columns": ["COMMENTS"], "rows": [], "affected_rows": 0, "execution_time_ms": 0}}),+ 0,+ ),+ (error.clone(), comment_response(), 1),+ (column_response(), error.clone(), 1),+ (error.clone(), error, 0),+ ] {+ for object_type in [None, Some(ObjectSourceKind::View)] {+ let source = if object_type.is_none() {+ "CREATE TABLE \"HR\".\"ORDERS\" (\"ID\" NUMBER);"+ } else {+ "CREATE VIEW \"HR\".\"ORDERS\" AS SELECT 1 FROM DUAL -- tail;"+ };+ let (state, dir) = scripted_oracle_driver(+ json!({"result": {"name": "ORDERS", "object_type": if object_type.is_some() { "VIEW" } else { "TABLE" }, "schema": "HR", "source": source}}),+ columns.clone(), comment.clone(),+ ).await;+ let ddl = crate::schema::get_table_display_ddl_core(+ &state,+ "oracle-ddl",+ "demo",+ "hr",+ "ORDERS",+ object_type,+ )+ .await+ .unwrap();+ assert!(ddl.starts_with(source), "{ddl}");+ assert_eq!(ddl.matches("COMMENT ON").count(), comment_count, "{ddl}");+ assert_eq!(+ crate::sql::split_sql_statements_for_database(&ddl, DatabaseType::Oracle).len(),+ 1 + comment_count,+ "{ddl}"+ );+ state.shutdown(Duration::from_secs(1)).await;+ std::fs::remove_dir_all(dir).unwrap();+ }+ }+ }++ #[tokio::test]+ async fn missing_or_failed_source_stops_before_comment_lookups() {+ for (object_type, response) in [+ (None, json!({"result": {}})),+ (None, json!({"result": {"source": " "}})),+ (None, json!({"error": {"message": "source denied"}})),+ (Some(ObjectSourceKind::View), json!({"error": {"message": "source denied"}})),+ ] {+ let (state, dir) = scripted_oracle_driver(response, column_response(), comment_response()).await;+ let result = crate::schema::get_table_display_ddl_core(+ &state,+ "oracle-ddl",+ "demo",+ "hr",+ "ORDERS",+ object_type,+ )+ .await;+ assert!(result.is_err());+ assert!(driver_calls(&dir).iter().all(|call| call["method"] == "getObjectSource"));+ state.shutdown(Duration::from_secs(1)).await;+ std::fs::remove_dir_all(dir).unwrap();+ }+ }+ }++ #[test]+ fn should_append_oracle_style_comment_ddl_for_oracle_family() {+ assert!(should_append_oracle_style_comment_ddl(Some(&test_connection_config(DatabaseType::Oracle))));+ assert!(should_append_oracle_style_comment_ddl(Some(&test_connection_config(DatabaseType::OceanbaseOracle))));+ assert!(should_append_oracle_style_comment_ddl(Some(&test_connection_config(DatabaseType::Dameng))));+ assert!(!should_append_oracle_style_comment_ddl(Some(&test_connection_config(DatabaseType::Mysql))));+ assert!(!should_append_oracle_style_comment_ddl(None));++ let mut jdbc_oracle = test_connection_config(DatabaseType::Jdbc);+ jdbc_oracle.connection_string = Some("jdbc:oracle:thin:@localhost:1521/ORCL".to_string());+ assert!(should_append_oracle_style_comment_ddl(Some(&jdbc_oracle)));+ }+#[test]fn external_driver_generic_ddl_applies_to_unmatched_jdbc_connections() {// JDBCX-style wrappers match no vendor DDL dialect and fall back to the@@ -8092,18 +8368,37 @@ async fn get_table_ddl_core_with_options(None,).await?;- let database_type = connection_config(state, connection_id).await.map(|config| config.db_type);+ let db_config = connection_config(state, connection_id).await;+ let append_oracle_comments = should_append_oracle_style_comment_ddl(db_config.as_ref());+ let schema = if append_oracle_comments {+ source.schema.as_deref().filter(|schema| !schema.trim().is_empty()).unwrap_or(schema)+ } else {+ schema+ };+ let database_type = db_config.as_ref().map(|config| {+ if is_oracle_external_driver_config(config) {+ DatabaseType::Oracle+ } else {+ config.db_type+ }+ });// Kingbase MySQL compatibility mode reports a backtick identifier// quote; thread it through so the view DDL wraps hyphenated schema// names in backticks instead of double quotes the server rejects.let identifier_quote = state.connection_identifier_quote(connection_id, Some(database)).await.ok().flatten();- return Ok(crate::object_source_sql::build_view_ddl_sql(crate::object_source_sql::BuildViewDdlInput {+ let ddl = crate::object_source_sql::build_view_ddl_sql(crate::object_source_sql::BuildViewDdlInput {database_type,schema: if schema.trim().is_empty() { None } else { Some(schema.to_string()) },name: table.to_string(),source: source.source,identifier_quote,- }));+ });+ // Oracle-family comments live in dictionary tables, not inside CREATE VIEW.+ // Append COMMENT ON so table-properties DDL / hover match the structure editor.+ if append_oracle_comments {+ return Ok(enrich_ddl_with_oracle_style_comments(state, connection_id, database, schema, table, &ddl).await);+ }+ return Ok(ddl);}if matches!(object_type, Some(db::ObjectSourceKind::MaterializedView)) {let source = get_object_source_core(@@ -9780,11 +10075,10 @@ fn append_oracle_comments_to_ddl(table_comment: Option<&str>,columns: &[db::ColumnInfo],) -> String {- let mut result = ddl.trim_end().trim_end_matches(';').to_string();+ let mut result = crate::object_source_sql::ensure_oracle_ddl_terminated(ddl);if result.trim().is_empty() {return result;}- result.push(';');let existing_ddl_upper = ddl.to_ascii_uppercase();let table_ref = if schema.trim().is_empty() {@@ -9812,6 +10106,75 @@ fn append_oracle_comments_to_ddl(result}+fn should_append_oracle_style_comment_ddl(config: Option<&ConnectionConfig>) -> bool {+ config.is_some_and(|config| {+ matches!(config.db_type, DatabaseType::Oracle | DatabaseType::OceanbaseOracle | DatabaseType::Dameng)+ || is_oracle_external_driver_config(config)+ })+}++/// Enrich display DDL with dictionary comments for Oracle-family engines.+/// Failures are logged and the original DDL is returned unchanged.+async fn enrich_ddl_with_oracle_style_comments(+ state: &AppState,+ connection_id: &str,+ database: &str,+ schema: &str,+ table: &str,+ ddl: &str,+) -> String {+ let columns = match get_columns_core(state, connection_id, database, schema, table).await {+ Ok(columns) => columns,+ Err(error) => {+ log::debug!(+ "[schema][oracle:display-ddl:columns-for-comments-failed] connection_id={} schema={} table={} error={}",+ connection_id,+ schema,+ table,+ error+ );+ Vec::new()+ }+ };+ let table_comment = match get_table_comment_core(state, connection_id, database, schema, table).await {+ Ok(comment) => comment,+ Err(error) => {+ log::debug!(+ "[schema][oracle:display-ddl:table-comment-failed] connection_id={} schema={} table={} error={}",+ connection_id,+ schema,+ table,+ error+ );+ None+ }+ };+ append_oracle_comments_to_ddl(ddl, schema, table, table_comment.as_deref(), &columns)+}++async fn external_driver_oracle_table_comment(+ session: std::sync::Arc<crate::plugins::PluginDriverSession>,+ config: &ConnectionConfig,+ database: &str,+ schema: &str,+ table: &str,+) -> Result<Option<String>, String> {+ let result: db::QueryResult = session+ .invoke_with_timeout(+ "executeQuery",+ serde_json::json!({+ "connection": config,+ "database": database,+ "schema": schema,+ "sql": oracle_table_comment_sql(schema, table),+ "maxRows": 1+ }),+ agent_metadata_timeout(Some(config)),+ )+ .await?;+ oracle_table_comment_from_query_result(result)+}+async fn db2_agent_table_ddl(client: Arc<db::agent_driver::PooledAgentClient>,database: &str,@@ -10450,6 +10813,95 @@ mod object_source_tests {assert!(!ddl.contains("EMPTY_COMMENT\" IS"));}+ #[test]+ fn appends_oracle_comments_to_view_ddl() {+ let column = db::ColumnInfo {+ name: "STATUS".to_string(),+ data_type: "VARCHAR2(20)".to_string(),+ is_nullable: true,+ column_default: None,+ is_primary_key: false,+ extra: None,+ comment: Some("Order status".to_string()),+ numeric_precision: None,+ numeric_scale: None,+ character_maximum_length: None,+ enum_values: None,+ ..Default::default()+ };++ let ddl = append_oracle_comments_to_ddl(+ "CREATE OR REPLACE VIEW \"HR\".\"ACTIVE_ORDERS\" AS\nSELECT \"STATUS\" FROM \"HR\".\"ORDERS\"",+ "HR",+ "ACTIVE_ORDERS",+ Some("Open orders view"),+ &[column],+ );++ assert!(ddl.contains("CREATE OR REPLACE VIEW \"HR\".\"ACTIVE_ORDERS\" AS"));+ assert!(ddl.contains("COMMENT ON TABLE \"HR\".\"ACTIVE_ORDERS\" IS 'Open orders view';"));+ assert!(ddl.contains("COMMENT ON COLUMN \"HR\".\"ACTIVE_ORDERS\".\"STATUS\" IS 'Order status';"));+ }++ #[test]+ fn oracle_view_comment_ddl_preserves_statement_boundaries() {+ use crate::object_source_sql::{build_view_ddl_sql, BuildViewDdlInput};+ use crate::sql::split_sql_statements_for_database;++ let column =+ db::ColumnInfo { name: "ID".into(), comment: Some("Column's comment".into()), ..Default::default() };+ for (source, terminated) in [+ ("SELECT 1 FROM DUAL", "SELECT 1 FROM DUAL;"),+ ("SELECT 1 FROM DUAL;", "SELECT 1 FROM DUAL;"),+ ("SELECT 1 FROM DUAL -- tail", "SELECT 1 FROM DUAL -- tail\n;"),+ ("SELECT 1 FROM DUAL -- tail;\n", "SELECT 1 FROM DUAL -- tail;\n;"),+ ("SELECT 1 FROM DUAL -- tail /", "SELECT 1 FROM DUAL -- tail /\n;"),+ ("SELECT 1 FROM DUAL; -- tail;", "SELECT 1 FROM DUAL; -- tail;"),+ ("SELECT 1 FROM DUAL; /* tail; */", "SELECT 1 FROM DUAL; /* tail; */"),+ ("SELECT 1 FROM DUAL /* tail; */", "SELECT 1 FROM DUAL /* tail; */;"),+ ("SELECT '--;' AS \"--ID\" FROM DUAL -- tail", "SELECT '--;' AS \"--ID\" FROM DUAL -- tail\n;"),+ ] {+ for database_type in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle, DatabaseType::Dameng] {+ for full_source in [false, true] {+ let prefix = "CREATE VIEW \"HR\".\"ACTIVE_ORDERS\" AS\n";+ let ddl = build_view_ddl_sql(BuildViewDdlInput {+ database_type: Some(database_type),+ schema: Some("HR".into()),+ name: "ACTIVE_ORDERS".into(),+ source: if full_source { format!("{prefix}{source}") } else { source.to_string() },+ identifier_quote: None,+ });+ let expected_base = format!("{prefix}{terminated}");+ assert_eq!(ddl, expected_base, "{database_type:?}: {source}");+ for table_comment in [None, Some("View's comment")] {+ for columns in [&[][..], std::slice::from_ref(&column)] {+ let enriched =+ append_oracle_comments_to_ddl(&ddl, "HR", "ACTIVE_ORDERS", table_comment, columns);+ let mut expected = expected_base.clone();+ if table_comment.is_some() {+ expected.push_str("\nCOMMENT ON TABLE \"HR\".\"ACTIVE_ORDERS\" IS 'View''s comment';");+ }+ if !columns.is_empty() {+ expected.push_str(+ "\nCOMMENT ON COLUMN \"HR\".\"ACTIVE_ORDERS\".\"ID\" IS 'Column''s comment';",+ );+ }+ assert_eq!(enriched, expected);+ let statements = split_sql_statements_for_database(&enriched, database_type);+ assert_eq!(+ statements.len(),+ 1 + usize::from(table_comment.is_some()) + columns.len(),+ "{enriched}"+ );+ assert!(!statements[0].contains("COMMENT ON"), "{enriched}");+ }+ }+ }+ }+ }+ assert_eq!(append_oracle_comments_to_ddl("", "HR", "EMPTY", Some("ignored"), &[column]), "");+ }+#[test]fn does_not_duplicate_existing_oracle_comment_ddl() {let column = db::ColumnInfo {@@ -11672,12 +12124,53 @@ async fn external_driver_oracle_ddl(agent_metadata_timeout(Some(config)),).await?;- result+ let ddl = result.get("source").and_then(serde_json::Value::as_str).filter(|source| !source.trim().is_empty()).map(str::to_string)- .ok_or_else(|| "JDBC Oracle plugin returned no table DDL".to_string())+ .ok_or_else(|| "JDBC Oracle plugin returned no table DDL".to_string())?;+ let schema = result+ .get("schema")+ .and_then(serde_json::Value::as_str)+ .filter(|schema| !schema.trim().is_empty())+ .unwrap_or(schema);++ // DBMS_METADATA.GET_DDL omits dictionary comments; append COMMENT ON like the native agent path.+ let columns = session+ .invoke_with_timeout::<Vec<db::ColumnInfo>>(+ "getColumns",+ serde_json::json!({+ "connection": config,+ "database": database,+ "schema": schema,+ "table": table,+ }),+ agent_metadata_timeout(Some(config)),+ )+ .await+ .unwrap_or_else(|error| {+ log::debug!(+ "[schema][jdbc-oracle:get_table_ddl:columns-for-comments-failed] schema={} table={} error={}",+ schema,+ table,+ error+ );+ Vec::new()+ });+ let table_comment = match external_driver_oracle_table_comment(session, config, database, schema, table).await {+ Ok(comment) => comment,+ Err(error) => {+ log::debug!(+ "[schema][jdbc-oracle:get_table_ddl:table-comment-failed] schema={} table={} error={}",+ schema,+ table,+ error+ );+ None+ }+ };+ Ok(append_oracle_comments_to_ddl(&ddl, schema, table, table_comment.as_deref(), &columns))}/// External JDBC connections that match no vendor DDL dialect (JDBCX wrappers,