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(schema-diff): correct Oracle/JDBC column, index and view diffs
zipg70569e556f75
diff --git a/apps/desktop/src/components/diff/SchemaDiffDialog.vue b/apps/desktop/src/components/diff/SchemaDiffDialog.vueindex 96d7cd5443..ffa3c21772 100644--- a/apps/desktop/src/components/diff/SchemaDiffDialog.vue+++ b/apps/desktop/src/components/diff/SchemaDiffDialog.vue@@ -40,6 +40,7 @@ import {schemaDiffDeployTargetSchema,normalizeDialectKind,databaseTypeToDialectKind,+ schemaDiffEngineDatabaseType,findSchemaDiffObject,flattenSchemaDiffObjects,schemaDiffSelectionTargets,@@ -107,6 +108,10 @@ const showFieldMappingDialog = ref(false);const showConfigSelector = ref(false);const sourceDbType = computed(() => store.getConfig(sourceConnectionId.value)?.db_type ?? "");const targetDbType = computed(() => store.getConfig(targetConnectionId.value)?.db_type ?? "");+// A JDBC connection stores `jdbc` in db_type while its product lives in the driver+// profile; the diff engine needs the product for clause shapes and view comparison.+const sourceEngineDbType = computed(() => schemaDiffEngineDatabaseType(store.getConfig(sourceConnectionId.value)));+const targetEngineDbType = computed(() => schemaDiffEngineDatabaseType(store.getConfig(targetConnectionId.value)));// Clear stale field mappings when source and target are the same typewatch([sourceDbType, targetDbType], ([src, tgt]) => {@@ -742,6 +747,8 @@ function handleCompare(): void {targetSchema: targetSchema.value,sourceDbType,targetDbType,+ sourceEngineDbType: sourceEngineDbType.value,+ targetEngineDbType: targetEngineDbType.value,options,ignoreComments: ignoreComments.value,label: `${comparisonEndpointLabel(sourceConnectionId.value, sourceDatabase.value, sourceSchema.value)} → ${comparisonEndpointLabel(targetConnectionId.value, targetDatabase.value, targetSchema.value)}`,@@ -802,11 +809,12 @@ function rebuildDiffGroups() {}function buildSchemaSyncPlanOptions(options: SchemaDiffCompareOptions) {+ const engineDbType = targetEngineDbType.value ?? getDbType();return {- databaseType: getDbType(),+ databaseType: engineDbType,targetSchema: schemaDiffDeployTargetSchema(getDbType(), targetDatabase.value, targetSchema.value),cascadeDelete: options.cascadeDelete,- sourceDialect: options.sourceDialect ? normalizeDialectKind(options.sourceDialect) : sourceDbType.value ? databaseTypeToDialectKind(sourceDbType.value) : undefined,+ sourceDialect: options.sourceDialect ? normalizeDialectKind(options.sourceDialect) : sourceEngineDbType.value ? databaseTypeToDialectKind(sourceEngineDbType.value) : undefined,fieldMappings: options.fieldMappings,enableRollback: options.enableRollback,};diff --git a/apps/desktop/src/composables/__tests__/useSchemaDiffSession.spec.ts b/apps/desktop/src/composables/__tests__/useSchemaDiffSession.spec.tsindex b2aadae38d..8f672311ea 100644--- a/apps/desktop/src/composables/__tests__/useSchemaDiffSession.spec.ts+++ b/apps/desktop/src/composables/__tests__/useSchemaDiffSession.spec.ts@@ -322,3 +322,47 @@ test("skips table list loading for routines-only compares", async () => {assert.equal(apiMock.listFunctions.mock.calls.length, 2);assert.deepEqual(apiMock.prepareSchemaDiff.mock.calls[0]?.[0]?.sourceTables, []);});++test("resolves the JDBC engine dialect from the connection's product type", async () => {+ // 「Oracle (JDBC)」这类连接的 db_type 是 jdbc,后端 DialectKind 认不出它:对话框把产品类型+ // 解析出来传进 sourceEngineDbType/targetEngineDbType 后,方言(以及视图比较)才成立。+ apiMock.prepareSchemaDiff.mockClear();+ apiMock.prepareSchemaDiff.mockResolvedValue({+ diffs: [],+ functionDiffs: [],+ sequenceDiffs: [],+ ruleDiffs: [],+ ownerDiffs: [],+ renameCandidates: [],+ syncSql: "",+ rollbackSyncSql: "",+ });++ const session = startSchemaDiffSession(+ {+ sourceConnectionId: "jdbc-src",+ sourceDatabase: "XE",+ sourceSchema: "DBX_TEST",+ targetConnectionId: "jdbc-dst",+ targetDatabase: "XE",+ targetSchema: "DBX_TGT",+ sourceDbType: "jdbc",+ targetDbType: "jdbc",+ sourceEngineDbType: "oracle",+ targetEngineDbType: "oracle",+ options: {},+ ignoreComments: false,+ label: "jdbc oracle",+ },+ { tableListLoader: { load: vi.fn().mockResolvedValue([]) } },+ );++ await waitForSession(session);++ assert.equal(session.status, "completed");+ const payload = apiMock.prepareSchemaDiff.mock.calls[0]?.[0];+ assert.equal(payload?.sourceDialect, "oracle");+ assert.equal(payload?.targetDialect, "oracle");+ // 部署脚本按目标产品类型(而不是 jdbc)生成。+ assert.equal(payload?.databaseType, "oracle");+});diff --git a/apps/desktop/src/composables/useSchemaDiffSession.ts b/apps/desktop/src/composables/useSchemaDiffSession.tsindex 02a91df436..1aa40ff153 100644--- a/apps/desktop/src/composables/useSchemaDiffSession.ts+++ b/apps/desktop/src/composables/useSchemaDiffSession.ts@@ -31,6 +31,13 @@ export interface SchemaDiffSessionConfig {targetSchema: string;sourceDbType: string;targetDbType: DatabaseType;+ /**+ * Product type behind a JDBC `sourceDbType`/`targetDbType` (see+ * `schemaDiffEngineDatabaseType`). Only the diff engine's dialect/profile decisions use+ * it: metadata loading, progress phases and option defaults keep the raw db types.+ */+ sourceEngineDbType?: DatabaseType;+ targetEngineDbType?: DatabaseType;options: SchemaDiffCompareOptions;ignoreComments: boolean;label: string;@@ -56,6 +63,11 @@ export interface SchemaDiffSessionDependencies {const sessions = reactive(new Map<string, SchemaDiffSession>());+function schemaDiffDialect(dbType: DatabaseType | string | undefined, explicit: string | undefined): string | undefined {+ if (explicit) return normalizeDialectKind(explicit);+ return dbType ? databaseTypeToDialectKind(dbType as DatabaseType) : undefined;+}+function cloneOptions(options: SchemaDiffCompareOptions): SchemaDiffCompareOptions {return {...options,@@ -209,7 +221,7 @@ async function runSchemaDiffSession(session: SchemaDiffSession, dependencies: ScsourceOwners,targetOwners,tableMappings: sessionOptions.selectedTables === undefined ? undefined : sessionOptions.tableMappings,- databaseType: input.targetDbType,+ databaseType: input.targetEngineDbType ?? input.targetDbType,targetSchema: schemaDiffDeployTargetSchema(input.targetDbType, input.targetDatabase, input.targetSchema),ignoreComments: input.ignoreComments,cascadeDelete: sessionOptions.cascadeDelete ?? false,@@ -226,8 +238,8 @@ async function runSchemaDiffSession(session: SchemaDiffSession, dependencies: Sc.map((value) => value.trim()).filter(Boolean): undefined,- sourceDialect: sessionOptions.sourceDialect ? normalizeDialectKind(sessionOptions.sourceDialect) : input.sourceDbType ? databaseTypeToDialectKind(input.sourceDbType as DatabaseType) : undefined,- targetDialect: sessionOptions.targetDialect ? normalizeDialectKind(sessionOptions.targetDialect) : input.targetDbType ? databaseTypeToDialectKind(input.targetDbType) : undefined,+ sourceDialect: schemaDiffDialect(input.sourceEngineDbType ?? input.sourceDbType, sessionOptions.sourceDialect),+ targetDialect: schemaDiffDialect(input.targetEngineDbType ?? input.targetDbType, sessionOptions.targetDialect),compatibilityThreshold: sessionOptions.compatibilityThreshold ?? 0.5,fieldMappings:sessionOptions.fieldMappings?.map((mapping) => ({diff --git a/apps/desktop/src/lib/schema/__tests__/schemaDiffEngineDatabaseType.spec.ts b/apps/desktop/src/lib/schema/__tests__/schemaDiffEngineDatabaseType.spec.tsnew file mode 100644index 0000000000..84c76d9b30--- /dev/null+++ b/apps/desktop/src/lib/schema/__tests__/schemaDiffEngineDatabaseType.spec.ts@@ -0,0 +1,41 @@+import { describe, expect, it } from "vitest";+import { schemaDiffEngineDatabaseType } from "@/lib/schema/schemaDiff";++describe("schemaDiffEngineDatabaseType", () => {+ it("resolves the product type of a JDBC connection from the driver profile", () => {+ expect(schemaDiffEngineDatabaseType({ db_type: "jdbc", driver_profile: "jdbc-oracle" })).toBe("oracle");+ expect(schemaDiffEngineDatabaseType({ db_type: "jdbc", driver_profile: "jdbc-mysql" })).toBe("mysql");+ expect(schemaDiffEngineDatabaseType({ db_type: "jdbc", driver_profile: "jdbc-postgresql" })).toBe("postgres");+ });++ it("resolves the product type from the JDBC URL, driver class and labels", () => {+ expect(+ schemaDiffEngineDatabaseType({+ db_type: "jdbc",+ connection_string: "jdbc:oracle:thin:@192.168.58.103:15211:XE",+ jdbc_driver_class: "oracle.jdbc.OracleDriver",+ }),+ ).toBe("oracle");+ expect(+ schemaDiffEngineDatabaseType({+ db_type: "jdbc",+ jdbc_driver_paths: ["/plugins/jdbc/drivers/local/ojdbc8-21.9.0.0.jar"],+ jdbc_driver_class: "com.mysql.cj.jdbc.Driver",+ connection_string: "jdbc:mysql://127.0.0.1:3306/db",+ }),+ ).toBe("mysql");+ expect(schemaDiffEngineDatabaseType({ db_type: "jdbc", driver_label: "Apache Hive" })).toBe("hive");+ });++ it("keeps generic JDBC connections on the generic type", () => {+ expect(schemaDiffEngineDatabaseType({ db_type: "jdbc" })).toBe("jdbc");+ expect(schemaDiffEngineDatabaseType({ db_type: "jdbc", driver_profile: "jdbcx" })).toBe("jdbc");+ });++ it("leaves non-JDBC connections untouched", () => {+ expect(schemaDiffEngineDatabaseType({ db_type: "oracle" })).toBe("oracle");+ expect(schemaDiffEngineDatabaseType({ db_type: "mysql", driver_profile: "starrocks" })).toBe("mysql");+ expect(schemaDiffEngineDatabaseType({ db_type: "postgres" })).toBe("postgres");+ expect(schemaDiffEngineDatabaseType(undefined)).toBeUndefined();+ });+});diff --git a/apps/desktop/src/lib/schema/schemaDiff.ts b/apps/desktop/src/lib/schema/schemaDiff.tsindex 97f9fd4739..601c5efb44 100644--- a/apps/desktop/src/lib/schema/schemaDiff.ts+++ b/apps/desktop/src/lib/schema/schemaDiff.ts@@ -1,5 +1,6 @@-import type { ColumnInfo, IndexInfo, ForeignKeyInfo, TriggerInfo, FunctionInfo, SequenceInfo, RuleInfo, OwnerInfo, DatabaseType, TableInfo } from "@/types/database";+import type { ColumnInfo, IndexInfo, ForeignKeyInfo, TriggerInfo, FunctionInfo, SequenceInfo, RuleInfo, OwnerInfo, DatabaseType, TableInfo, ConnectionConfig } from "@/types/database";import type { SchemaDiffTableMapping } from "@/types/schemaDiff";+import { effectiveDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";import { splitSqlStatementRanges } from "@/lib/sql/sqlStatementRanges";const DIALECT_KIND_MAP: Record<string, string> = {@@ -44,6 +45,24 @@ export function databaseTypeToDialectKind(dbType: DatabaseType): string {return DIALECT_KIND_MAP[dbType] ?? "unsupported";}+/** The connection fields the JDBC product inference reads. */+export type SchemaDiffDialectConnection = Partial<Pick<ConnectionConfig, "db_type" | "driver_profile" | "driver_label" | "connection_string" | "url_params" | "jdbc_driver_class" | "jdbc_driver_paths" | "database_info" | "external_config" | "username">>;++/**+ * Product type the schema-diff engine must treat a connection as.+ *+ * A JDBC connection stores the generic `jdbc` in `db_type`, but the engine keys its clause+ * shapes, index rules and view comparison off the product type — diffing a JDBC Oracle+ * connection as `jdbc` emits ANSI/MySQL clauses for it and never compares its view text.+ * The product is resolved from the driver profile/URL exactly like the metadata and query+ * paths already resolve it; every other connection keeps its own `db_type`.+ */+export function schemaDiffEngineDatabaseType(connection: SchemaDiffDialectConnection | undefined): DatabaseType | undefined {+ if (!connection?.db_type) return undefined;+ if (connection.db_type !== "jdbc") return connection.db_type as DatabaseType;+ return effectiveDatabaseTypeForConnection(connection) ?? (connection.db_type as DatabaseType);+}+const DIALECT_ALIAS_MAP: Record<string, string> = {access: "sql_server",mssql: "sql_server",diff --git a/crates/dbx-sql/src/schema_diff.rs b/crates/dbx-sql/src/schema_diff.rsindex 42a1e899b8..6a735ffe76 100644--- a/crates/dbx-sql/src/schema_diff.rs+++ b/crates/dbx-sql/src/schema_diff.rs@@ -294,6 +294,54 @@ fn with_known_length(source_type: &str, character_maximum_length: Option<i32>) -}}+/// Numeric base types whose `(precision[, scale])` is part of the *declared* type on every+/// dialect that spells the name that way. Oracle's `ALL_TAB_COLUMNS` — and therefore every+/// Oracle introspection path, native agent and JDBC alike — reports a bare `NUMBER` with+/// `DATA_PRECISION`/`DATA_SCALE` beside it, so comparing the type strings alone cannot tell+/// `NUMBER(10,2)` from `NUMBER(12,2)` and the difference is silently dropped from the+/// result (#9261). Integer families are deliberately excluded: MySQL's `information_schema`+/// fills `numeric_precision` in for `int` (10) and rendering that back as `int(10)` would+/// invent a display width that a Postgres target rejects.+const NUMERIC_TYPES_WITH_DECLARED_PRECISION: [&str; 5] = ["NUMBER", "NUMERIC", "DECIMAL", "DEC", "FIXED"];++/// Counterpart of [`with_known_length`] for the numeric family: splices a driver-reported+/// precision/scale back into a type name that omits them. A negative scale (`NUMBER(10,-2)`+/// on Oracle) is preserved because it changes the value range, while a scale of zero is+/// left out — `NUMBER(10)` and `NUMBER(10,0)` are the same column.+fn with_known_numeric_precision(+ source_type: &str,+ numeric_precision: Option<i32>,+ numeric_scale: Option<i32>,+) -> String {+ let trimmed = source_type.trim();+ if trimmed.contains('(') {+ return trimmed.to_string();+ }+ let base = trimmed.split([' ', '(']).next().unwrap_or_default().to_ascii_uppercase();+ if !NUMERIC_TYPES_WITH_DECLARED_PRECISION.contains(&base.as_str()) {+ return trimmed.to_string();+ }+ let Some(precision) = numeric_precision.filter(|value| *value > 0) else {+ return trimmed.to_string();+ };+ match numeric_scale {+ Some(scale) if scale != 0 => format!("{trimmed}({precision},{scale})"),+ _ => format!("{trimmed}({precision})"),+ }+}++/// The declared shape of a column: the driver's type string with every length/precision it+/// reports *beside* the string spliced back in. Comparison needs it so that a changed+/// precision or length is a difference at all, and scripts need it so that an emitted+/// `ADD COLUMN`/`MODIFY` keeps the parameters the user declared.+fn declared_column_type(column: &ColumnInfo) -> String {+ with_known_numeric_precision(+ &with_known_length(&column.data_type, column.character_maximum_length),+ column.numeric_precision,+ column.numeric_scale,+ )+}+impl FieldMapping {pub fn apply<'a>(mappings: &'a [FieldMapping], source_type: &str) -> Option<&'a str> {let base_type = source_type.split('(').next().unwrap_or(source_type).trim();@@ -2491,7 +2539,7 @@ fn diff_schema(options: &SchemaDiffPreparationOptions) -> Vec<TableDiff> {let Some(target_ddl) = target_details.get(target_name.as_str()).and_then(|detail| detail.ddl.as_ref()) else {continue;};- if !mysql_view_definitions_differ(source_ddl, target_ddl, options.source_dialect, options.target_dialect) {+ if !view_definitions_differ(source_ddl, target_ddl, options.source_dialect, options.target_dialect) {continue;}@@ -2595,17 +2643,36 @@ fn diff_names(source: &[String], target: &[String]) -> (Vec<String>, Vec<String>)}-fn mysql_view_definitions_differ(+/// Whether two captured view definitions differ.+///+/// Only dialects whose captured text `dbx` can normalize are compared: a view body is+/// dialect-specific SQL, so a cross-dialect pair (or an engine whose text nobody taught+/// this function to read) is left alone rather than reported as a difference.+fn view_definitions_differ(source_ddl: &str,target_ddl: &str,source_dialect: Option<DialectKind>,target_dialect: Option<DialectKind>,) -> bool {- if source_dialect != Some(DialectKind::Mysql) || target_dialect != Some(DialectKind::Mysql) {+ if source_dialect != target_dialect {return false;}- normalize_mysql_view_ddl(source_ddl) != normalize_mysql_view_ddl(target_ddl)+ match source_dialect {+ Some(DialectKind::Mysql) => normalize_mysql_view_ddl(source_ddl) != normalize_mysql_view_ddl(target_ddl),+ Some(DialectKind::Oracle) => {+ // Each side's view lives in its own schema, and Oracle hands the body back exactly+ // as it was written. dbx's own generated script rewrites only the header, so after+ // applying it the target body can still qualify the *source* schema — normalising+ // references to either compared schema keeps the comparison idempotent instead of+ // reporting the view as permanently modified.+ let schemas = oracle_view_schemas(source_ddl, target_ddl);+ let schemas: Vec<&str> = schemas.iter().map(String::as_str).collect();+ normalize_oracle_view_ddl_with_schemas(source_ddl, &schemas)+ != normalize_oracle_view_ddl_with_schemas(target_ddl, &schemas)+ }+ _ => false,+ }}#[derive(Clone, Copy, PartialEq, Eq)]@@ -2656,13 +2723,13 @@ fn normalize_mysql_view_ddl(ddl: &str) -> String {let end = ddl[index + 2..].find("*/").map_or(bytes.len(), |offset| index + 2 + offset + 2);(end, MysqlViewTokenKind::Atom, None)}- byte if mysql_view_symbol(byte) => (index + 1, MysqlViewTokenKind::Symbol, None),+ byte if view_ddl_symbol(byte) => (index + 1, MysqlViewTokenKind::Symbol, None),_ => {let mut end = index + 1;while end < bytes.len()&& !bytes[end].is_ascii_whitespace()&& !matches!(bytes[end], b'\'' | b'"' | b'`' | b'#')- && !mysql_view_symbol(bytes[end])+ && !view_ddl_symbol(bytes[end]){end += 1;}@@ -2682,7 +2749,10 @@ fn normalize_mysql_view_ddl(ddl: &str) -> String {normalized}-fn mysql_view_symbol(byte: u8) -> bool {+/// Punctuation shared by the view-text tokenizers: MySQL and Oracle agree on every+/// operator and delimiter the server can put between two atoms, so one predicate keeps+/// the two normalizers from drifting apart.+fn view_ddl_symbol(byte: u8) -> bool {matches!(byte,b'(' | b')'@@ -2786,7 +2856,7 @@ fn parse_mysql_identifier(ddl: &str, index: usize) -> Option<(String, usize)> {let mut end = index;while let Some(byte) = ddl.as_bytes().get(end) {- if byte.is_ascii_whitespace() || mysql_view_symbol(*byte) {+ if byte.is_ascii_whitespace() || view_ddl_symbol(*byte) {break;}end += 1;@@ -2843,6 +2913,181 @@ fn mysql_quoted_token_end(ddl: &str, start: usize) -> usize {bytes.len()}+/// How `normalize_oracle_view_ddl` groups a token: anything the server reads as a+/// single value is an atom, everything else is punctuation.+#[derive(Clone, Copy, PartialEq, Eq)]+enum OracleViewTokenKind {+ Atom,+ Symbol,+}++struct OracleViewToken {+ kind: OracleViewTokenKind,+ text: String,+ /// Bare words and `"quoted"` identifiers are the ones that can name the owner;+ /// `'literals'` never are, so a literal that happens to spell the schema stays a+ /// literal.+ identifier: bool,+ /// Quoted identifiers keep their case and never spell a keyword.+ quoted: bool,+ /// Whether whitespace separated this token from the previous one.+ spaced: bool,+}++/// Normalizes Oracle view text so that two schemas holding the *same* view compare equal+/// and two holding different views do not (#9261).+///+/// Oracle reports it through `DBMS_METADATA`, which repeats the owner in the header+/// (`CREATE OR REPLACE FORCE VIEW "DBX_TEST"."V_SAME"`) and qualifies every reference in+/// the body with it (`FROM DBX_TEST.CMP_SAME`), so the owner is replaced by a placeholder+/// exactly like `normalize_mysql_view_ddl` does for its backtick schema qualifier. The+/// header (including the column list) stays part of the comparison because a view that+/// exposes different columns is a different view, and comments are dropped because they+/// carry no query semantics.+/// Test-facing shorthand for the single-sided normalisation: collapse only this statement's+/// own owner (production comparisons use `oracle_view_schemas` and normalise both sides+/// against every compared schema).+#[cfg(test)]+fn normalize_oracle_view_ddl(ddl: &str) -> String {+ let owner = oracle_view_owner(&oracle_view_tokens(ddl));+ let schemas: Vec<&str> = owner.as_deref().into_iter().collect();+ normalize_oracle_view_ddl_with_schemas(ddl, &schemas)+}++/// Every schema a pair of captured view definitions is allowed to qualify: each side's own+/// owner, so the header qualifier and a body that names either schema collapse to the same+/// placeholder.+fn oracle_view_schemas(source_ddl: &str, target_ddl: &str) -> Vec<String> {+ let mut schemas = Vec::new();+ for ddl in [source_ddl, target_ddl] {+ let Some(owner) = oracle_view_owner(&oracle_view_tokens(ddl)) else { continue };+ if !schemas.iter().any(|known: &String| known.eq_ignore_ascii_case(&owner)) {+ schemas.push(owner);+ }+ }+ schemas+}++fn normalize_oracle_view_ddl_with_schemas(ddl: &str, schemas: &[&str]) -> String {+ // `DBMS_METADATA` may or may not hand the statement over with its trailing `;` — the+ // terminator carries no meaning for the comparison. (A literal's own semicolon is+ // inside quotes, so the statement never ends with one there.)+ let ddl = ddl.trim_end();+ let ddl = ddl.strip_suffix(';').map_or(ddl, str::trim_end);+ let tokens = oracle_view_tokens(ddl);+ let mut normalized = String::with_capacity(ddl.len());+ let mut previous = None;++ for (position, token) in tokens.iter().enumerate() {+ let replacement = if token.identifier+ && schemas.iter().any(|schema| token.text.eq_ignore_ascii_case(schema))+ && oracle_view_tokens_continue_with_dot(&tokens, position)+ {+ "__dbx_schema__".to_string()+ } else {+ token.text.clone()+ };+ if token.spaced && previous == Some(token.kind) {+ normalized.push(' ');+ }+ normalized.push_str(&replacement);+ previous = Some(token.kind);+ }++ normalized+}++fn oracle_view_tokens_continue_with_dot(tokens: &[OracleViewToken], position: usize) -> bool {+ tokens.get(position + 1).is_some_and(|next| next.kind == OracleViewTokenKind::Symbol && next.text == ".")+}++/// The schema in `CREATE OR REPLACE FORCE VIEW "OWNER"."NAME"`, when the captured text+/// qualifies the view at all.+fn oracle_view_owner(tokens: &[OracleViewToken]) -> Option<String> {+ let view = tokens.iter().position(|token| !token.quoted && token.text.eq_ignore_ascii_case("VIEW"))?;+ let name = tokens.get(view + 1)?;+ oracle_view_tokens_continue_with_dot(tokens, view + 1).then(|| name.text.clone())+}++fn oracle_view_tokens(ddl: &str) -> Vec<OracleViewToken> {+ let bytes = ddl.as_bytes();+ let mut tokens = Vec::new();+ let mut index = 0;+ let mut spaced = false;++ while index < bytes.len() {+ if bytes[index].is_ascii_whitespace() {+ spaced = true;+ index += 1;+ continue;+ }++ let (end, kind, text, identifier, quoted, keep) = match bytes[index] {+ b'\'' => {+ let end = oracle_quoted_token_end(ddl, index);+ (end, OracleViewTokenKind::Atom, ddl[index..end].to_string(), false, false, true)+ }+ b'"' => {+ let end = oracle_quoted_token_end(ddl, index);+ (end, OracleViewTokenKind::Atom, decode_oracle_quoted_identifier(&ddl[index..end]), true, true, true)+ }+ b'-' if bytes.get(index + 1) == Some(&b'-') => {+ let end = ddl[index..].find('\n').map_or(bytes.len(), |offset| index + offset);+ (end, OracleViewTokenKind::Atom, String::new(), false, false, false)+ }+ b'/' if bytes.get(index + 1) == Some(&b'*') => {+ let end = ddl[index + 2..].find("*/").map_or(bytes.len(), |offset| index + 2 + offset + 2);+ (end, OracleViewTokenKind::Atom, String::new(), false, false, false)+ }+ byte if view_ddl_symbol(byte) => {+ (index + 1, OracleViewTokenKind::Symbol, ddl[index..index + 1].to_string(), false, false, true)+ }+ _ => {+ let mut end = index + 1;+ while end < bytes.len()+ && !bytes[end].is_ascii_whitespace()+ && !matches!(bytes[end], b'\'' | b'"')+ && !view_ddl_symbol(bytes[end])+ {+ end += 1;+ }+ (end, OracleViewTokenKind::Atom, ddl[index..end].to_string(), true, false, true)+ }+ };++ if keep {+ tokens.push(OracleViewToken { kind, text, identifier, quoted, spaced });+ }+ spaced = false;+ index = end;+ }++ tokens+}++/// Oracle ends a quoted token at the matching quote; a doubled quote is an escape+/// (there is no backslash escape).+fn oracle_quoted_token_end(ddl: &str, start: usize) -> usize {+ let bytes = ddl.as_bytes();+ let quote = bytes[start];+ let mut index = start + 1;+ while index < bytes.len() {+ if bytes[index] == quote {+ if bytes.get(index + 1) == Some("e) {+ index += 2;+ continue;+ }+ return index + 1;+ }+ index += 1;+ }+ bytes.len()+}++fn decode_oracle_quoted_identifier(identifier: &str) -> String {+ identifier.strip_prefix('"').and_then(|value| value.strip_suffix('"')).unwrap_or(identifier).replace("\"\"", "\"")+}+fn skip_ascii_whitespace(input: &str, mut index: usize) -> usize {while input.as_bytes().get(index).is_some_and(|byte| byte.is_ascii_whitespace()) {index += 1;@@ -3053,13 +3298,13 @@ fn diff_columns_with_identifier_options(if let Some(target_index) = column_matches[source_index] {let target_column = &target[target_index];let mut changes = Vec::new();- if !column_types_equal_for_dialects(- &source_column.data_type,- &target_column.data_type,- source_dialect,- target_dialect,- ) {- changes.push(format!("type: {} → {}", target_column.data_type, source_column.data_type));+ // Compare the *declared* type, not the raw driver string: Oracle reports+ // `NUMBER` with the precision/scale in separate fields, so `NUMBER(10,2)` and+ // `NUMBER(12,2)` would otherwise look identical (#9261).+ let source_type = declared_column_type(source_column);+ let target_type = declared_column_type(target_column);+ if !column_types_equal_for_dialects(&source_type, &target_type, source_dialect, target_dialect) {+ changes.push(format!("type: {target_type} → {source_type}"));}if source_column.is_nullable != target_column.is_nullable {changes.push(format!(@@ -3229,6 +3474,78 @@ fn identifier_lists_equal(left: &[String], right: &[String], ignore_column_name_&& left.iter().zip(right).all(|(left, right)| identifiers_equal(left, right, ignore_column_name_case))}+/// Names a server hands out on its own. Oracle names the index behind an *unnamed*+/// PRIMARY KEY / UNIQUE constraint `SYS_C<number>`, and that number is per-object, so two+/// structurally identical tables never agree on it — while Dameng and SQLite do the same+/// with `SYS_C…`/`sqlite_autoindex_…` shapes. Those names carry no user intent and must not+/// be compared as if they did.+fn index_name_is_server_generated(name: &str) -> bool {+ let upper = name.trim().to_ascii_uppercase();+ if let Some(digits) = upper.strip_prefix("SYS_C") {+ return !digits.is_empty() && digits.bytes().all(|byte| byte.is_ascii_digit());+ }+ upper.starts_with("SQLITE_AUTOINDEX_")+}++/// Everything that identifies an index apart from its name. Used to pair up two indexes+/// whose names differ only because the server generated them.+fn index_signatures_equal(source: &IndexInfo, target: &IndexInfo, ignore_column_name_case: bool) -> bool {+ source.is_unique == target.is_unique+ && source.index_type == target.index_type+ && source.filter == target.filter+ && source.column_opclasses == target.column_opclasses+ && source.key_options == target.key_options+ && index_columns_equal(source, target, ignore_column_name_case)+ && identifier_lists_equal(+ &source.included_columns.clone().unwrap_or_default(),+ &target.included_columns.clone().unwrap_or_default(),+ ignore_column_name_case,+ )+}++/// Pairs source indexes with the target index that is *the same index under a+/// server-generated name*, so comparing two structurally identical tables does not report+/// a phantom "index added + index removed" pair (#9261). Returns the target position for+/// every source position that was paired this way.+fn match_server_generated_indexes(+ source: &[IndexInfo],+ target: &[IndexInfo],+ ignore_column_name_case: bool,+) -> Vec<Option<usize>> {+ let source_names: HashSet<&str> = source.iter().map(|index| index.name.as_str()).collect();+ let target_names: HashSet<&str> = target.iter().map(|index| index.name.as_str()).collect();+ let mut matched_targets: HashSet<usize> = HashSet::new();+ let mut pairs: Vec<Option<usize>> = vec![None; source.len()];++ for (source_position, source_index) in source.iter().enumerate() {+ if source_index.is_primary || target_names.contains(source_index.name.as_str()) {+ continue;+ }+ let Some(target_position) = target.iter().enumerate().find_map(|(position, target_index)| {+ if matched_targets.contains(&position)+ || target_index.is_primary+ || source_names.contains(target_index.name.as_str())+ {+ return None;+ }+ // Only a server-generated name may stand in for a user-chosen one; two+ // deliberately different names stay a real difference.+ if !index_name_is_server_generated(&source_index.name)+ && !index_name_is_server_generated(&target_index.name)+ {+ return None;+ }+ index_signatures_equal(source_index, target_index, ignore_column_name_case).then_some(position)+ }) else {+ continue;+ };+ matched_targets.insert(target_position);+ pairs[source_position] = Some(target_position);+ }++ pairs+}+fn diff_indexes_with_options(source: &[IndexInfo],target: &[IndexInfo],@@ -3237,12 +3554,17 @@ fn diff_indexes_with_options(let mut diffs = Vec::new();let target_map: HashMap<&str, &IndexInfo> = target.iter().map(|index| (index.name.as_str(), index)).collect();let source_map: HashMap<&str, &IndexInfo> = source.iter().map(|index| (index.name.as_str(), index)).collect();+ let server_generated_pairs = match_server_generated_indexes(source, target, ignore_column_name_case);+ let paired_targets: HashSet<usize> = server_generated_pairs.iter().flatten().copied().collect();- for source_index in source {+ for (source_position, source_index) in source.iter().enumerate() {if source_index.is_primary {continue;}let Some(target_index) = target_map.get(source_index.name.as_str()) else {+ if server_generated_pairs[source_position].is_some() {+ continue;+ }diffs.push(IndexDiff {diff_type: "added".to_string(),name: source_index.name.clone(),@@ -3308,8 +3630,8 @@ fn diff_indexes_with_options(}}- for target_index in target {- if target_index.is_primary {+ for (target_position, target_index) in target.iter().enumerate() {+ if target_index.is_primary || paired_targets.contains(&target_position) {continue;}if !source_map.contains_key(target_index.name.as_str()) {@@ -3733,26 +4055,48 @@ fn quote_id(name: &str, db_type: DatabaseType) -> String {profile_for(db_type).quote_ident(name)}+/// The `NOT NULL` / `DEFAULT ...` tail of a column definition, in the order the target+/// dialect accepts. Oracle's grammar is `datatype [DEFAULT expr] [NOT NULL]` and rejects+/// the reverse order with `ORA-00907`, while MySQL/Postgres/SQLite write the constraint+/// first, so the order is dialect data (see `column_default_precedes_not_null`).+fn column_modifier_tail(+ profile: &DdlDialectProfile,+ col: &ColumnInfo,+ declared_type: &str,+ db_type: DatabaseType,+ source_dialect: Option<DialectKind>,+ skip_default: bool,+) -> String {+ let not_null = if col.is_nullable { String::new() } else { " NOT NULL".to_string() };+ let default = if skip_default {+ String::new()+ } else {+ col.column_default.as_ref().map_or_else(String::new, |value| {+ format!(+ " DEFAULT {}",+ default_literal(+ value,+ declared_type,+ effective_source_dialect(source_dialect, db_type),+ col.extra.as_deref()+ )+ )+ })+ };+ if profile.column_default_precedes_not_null {+ format!("{default}{not_null}")+ } else {+ format!("{not_null}{default}")+ }+}+fn column_def(col: &ColumnInfo, db_type: DatabaseType, source_dialect: Option<DialectKind>) -> String {if db_type == DatabaseType::SqlServer {return sqlserver_column_definition(col, &col.data_type, source_dialect, None);}let profile = profile_for(db_type);let mut definition = format!("{} {}", quote_id(&col.name, db_type), col.data_type);- if !col.is_nullable {- definition.push_str(" NOT NULL");- }- if let Some(default) = &col.column_default {- definition.push_str(&format!(- " DEFAULT {}",- default_literal(- default,- &col.data_type,- effective_source_dialect(source_dialect, db_type),- col.extra.as_deref()- )- ));- }+ definition.push_str(&column_modifier_tail(&profile, col, &col.data_type, db_type, source_dialect, false));// Suffix-style auto-increment is only valid in MySQL-family ALTER clauses// (ADD/MODIFY/CHANGE). Other dialects' identity clauses are order-sensitive// inside ADD COLUMN, so keep omitting them outside the MySQL family.@@ -3787,7 +4131,21 @@ const TABLE_DDL_HEADER_KEYWORDS: &[&str] =/// `CREATE VIEW`-family header keywords, covering the `OR REPLACE` and/// `MATERIALIZED` variants emitted by the Postgres/MySQL view DDL builders.-const VIEW_DDL_HEADER_KEYWORDS: &[&str] = &["CREATE MATERIALIZED VIEW", "CREATE OR REPLACE VIEW", "CREATE VIEW"];+const VIEW_DDL_HEADER_KEYWORDS: &[&str] = &[+ "CREATE MATERIALIZED VIEW",+ "CREATE OR REPLACE VIEW",+ // Oracle's `DBMS_METADATA` writes the `FORCE`/`EDITIONABLE` variants; without them an+ // Oracle view that exists only in the source kept the source schema in its header and+ // the sync script created it on the wrong schema (or failed on rights).+ "CREATE OR REPLACE FORCE EDITIONABLE VIEW",+ "CREATE OR REPLACE FORCE NONEDITIONABLE VIEW",+ "CREATE OR REPLACE EDITIONABLE VIEW",+ "CREATE OR REPLACE NONEDITIONABLE VIEW",+ "CREATE OR REPLACE FORCE VIEW",+ "CREATE OR REPLACE NOFORCE VIEW",+ "CREATE FORCE VIEW",+ "CREATE VIEW",+];/// Case-insensitive ASCII prefix check that avoids allocating an uppercased/// copy of `haystack` (which can be a whole multi-KB `CREATE TABLE` body) just@@ -4227,6 +4585,12 @@ fn drop_object_sql(diff: &TableDiff, db_type: DatabaseType, schema: Option<&str>name.replace('\'', "''"));}+ // Oracle only gained `IF EXISTS` in 23c, and Access/Firebird/Db2/Informix/HANA/Teradata+ // never had it; the comparison already knows the object exists on the target, so the+ // direct form is valid and sufficient — the same reasoning `drop_index_sql` uses.+ if !profile_for(db_type).drop_table_supports_if_exists {+ return format!("DROP {object_type} {name}{cascade};");+ }format!("DROP {object_type} IF EXISTS {name}{cascade};")}@@ -5110,7 +5474,7 @@ fn generate_create_table_sql(// Type rewrite: user mappings → profile type_map → DialectKind matrix → normalize.// Call sites must not branch on individual DatabaseType values.let map_type = |col: &ColumnInfo| -> String {- let source_type = with_known_length(&col.data_type, col.character_maximum_length);+ let source_type = declared_column_type(col);if let Some(user_target) = FieldMapping::apply_with_params(field_mappings, &source_type, target_dialect) {return user_target;}@@ -5157,22 +5521,7 @@ fn generate_create_table_sql(mapped_type.as_str()};let mut def = format!("{} {}", col_name, effective_type);- if !col.is_nullable {- def.push_str(" NOT NULL");- }- if !skip_default {- if let Some(default) = &col.column_default {- def.push_str(&format!(- " DEFAULT {}",- default_literal(- default,- &mapped_type,- effective_source_dialect(source_dialect, db_type),- col.extra.as_deref()- )- ));- }- }+ def.push_str(&column_modifier_tail(&profile, col, &mapped_type, db_type, source_dialect, skip_default));if profile.inline_column_comment {if let Some(comment) = col.comment.as_deref().filter(|c| !c.is_empty()) {def.push_str(&format!(" COMMENT {}", comment_literal(comment)));@@ -5198,22 +5547,7 @@ fn generate_create_table_sql(}AutoIncColumnBuild::Normal { skip_default } => {let mut def = format!("{} {}", col_name, mapped_type);- if !col.is_nullable {- def.push_str(" NOT NULL");- }- if !skip_default {- if let Some(default) = &col.column_default {- def.push_str(&format!(- " DEFAULT {}",- default_literal(- default,- &mapped_type,- effective_source_dialect(source_dialect, db_type),- col.extra.as_deref()- )- ));- }- }+ def.push_str(&column_modifier_tail(&profile, col, &mapped_type, db_type, source_dialect, skip_default));if profile.inline_column_comment {if let Some(comment) = col.comment.as_deref().filter(|c| !c.is_empty()) {def.push_str(&format!(" COMMENT {}", comment_literal(comment)));@@ -5721,13 +6055,15 @@ fn generate_schema_sync_sql_inner(let mut lines = Vec::new();let mut missing_objects: Vec<MissingRollbackObject> = Vec::new();let profile = profile_for(db_type);- // SQL Server has no DROP ... CASCADE syntax. Related constraints are handled- // explicitly by the comparison plan instead of appending an invalid clause.- let cascade = if cascade_delete && db_type != DatabaseType::SqlServer { " CASCADE" } else { "" };+ // SQL Server has no DROP ... CASCADE syntax (related constraints are handled explicitly+ // by the comparison plan), and Oracle spells the clause `CASCADE CONSTRAINTS` — which+ // `drop_table_supports_cascade` deliberately excludes — so an unknown dialect gets the+ // plain form instead of a clause its server would reject.+ let cascade = if cascade_delete && profile.drop_table_supports_cascade { " CASCADE" } else { "" };let map_type = |col: &ColumnInfo| -> String {let tgt = DialectKind::from_database_type(db_type);- let source_type = with_known_length(&col.data_type, col.character_maximum_length);+ let source_type = declared_column_type(col);if let Some(user_target) = FieldMapping::apply_with_params(field_mappings, &source_type, tgt) {return user_target;}@@ -5927,11 +6263,14 @@ fn generate_schema_sync_sql_inner(} else {String::new()};- parts.push(format!(- " ADD COLUMN {}{}",- column_def(&convert_col(source), db_type, source_dialect),- position- ));+ let definition = column_def(&convert_col(source), db_type, source_dialect);+ // Oracle has no `COLUMN` keyword here: it parenthesizes the whole+ // definition (`ADD (AMT NUMBER(12,2))`) instead.+ parts.push(if profile.add_column_uses_column_keyword {+ format!(" ADD COLUMN {definition}{position}")+ } else {+ format!(" ADD ({definition}){position}")+ });}}"removed" => {@@ -5966,6 +6305,25 @@ fn generate_schema_sync_sql_inner(schema,));}+ } else if profile.parenthesized_alter_column_clause {+ // Oracle spells the whole column change as one+ // `MODIFY (col definition)` clause, which also carries the+ // `DEFAULT`/`NOT NULL` order the server accepts.+ if column.changes.iter().any(|change| !change.starts_with("order:")) {+ let modify_keyword = profile.alter_modify_keyword();+ let mut definition = column_def(&mapped, db_type, source_dialect);+ // Re-stating a definition does *not* drop an existing+ // `NOT NULL` on Oracle (verified on 11g: the constraint+ // survives `MODIFY (c NUMBER(12,2))`), so relaxing a+ // column has to spell `NULL` out or the statement reports+ // success while the target keeps the old constraint.+ if source.is_nullable+ && column.changes.iter().any(|change| change.starts_with("nullable:"))+ {+ definition.push_str(" NULL");+ }+ parts.push(format!(" {modify_keyword} ({definition})"));+ }} else if profile.alter_uses_modify_column {if column.changes.iter().any(|change| !change.starts_with("order:")) {let modify_keyword = profile.alter_modify_keyword();@@ -6021,12 +6379,16 @@ fn generate_schema_sync_sql_inner(let old_name = quote_id(&target_col.name, db_type);let new_name = quote_id(&column.name, db_type);parts.push(format!(" RENAME COLUMN {old_name} TO {new_name}"));+ // Follow-up clauses keep the renamed column's shape in+ // sync; their spelling is dialect data because `TYPE` is+ // Postgres/ANSI grammar that Oracle rejects.if source.data_type.to_lowercase() != target_col.data_type.to_lowercase() {- parts.push(format!(" ALTER COLUMN {new_name} TYPE {}", mapped.data_type));+ parts.push(profile.alter_column_type_clause(&new_name, &mapped.data_type));}if source.is_nullable != target_col.is_nullable {- let action = if source.is_nullable { "DROP NOT NULL" } else { "SET NOT NULL" };- parts.push(format!(" ALTER COLUMN {new_name} {action}"));+ parts.push(+ profile.alter_column_nullability_clause(&new_name, source.is_nullable),+ );}}RenameColumnSyntax::AlterColumnRenameTo => {@@ -8021,7 +8383,9 @@ mod tests {fn oracle_same_dialect_operations() {let diffs = make_col_diffs(&[("id", "NUMBER"), ("name", "VARCHAR2(100)")], &[("id", "NUMBER")], false);let sql = gen_sql(wrap_table_diff("t", diffs), DatabaseType::Oracle, None);- assert!(sql.contains("ADD COLUMN"), "Oracle add: {sql}");+ // Oracle's ADD clause is parenthesized and has no `COLUMN` keyword.+ assert!(sql.contains("ADD (NAME VARCHAR2(100) NOT NULL)"), "Oracle add: {sql}");+ assert!(!sql.contains("ADD COLUMN"), "Oracle add must omit COLUMN: {sql}");assert!(!sql.contains('`'), "Oracle no backticks: {sql}");}@@ -8139,7 +8503,12 @@ mod tests {let diffs = make_col_diffs(&[("new1", "int"), ("new2", "varchar(10)")], &[], false);for db in [DatabaseType::Mysql, DatabaseType::Postgres, DatabaseType::Oracle] {let sql = gen_sql(wrap_table_diff("t", diffs.clone()), db, None);- assert_eq!(sql.matches("ADD COLUMN").count(), 2, "{db:?} two adds: {sql}");+ if db == DatabaseType::Oracle {+ assert_eq!(sql.matches("ADD (").count(), 2, "Oracle two adds: {sql}");+ assert!(!sql.contains("ADD COLUMN"), "Oracle add must omit COLUMN: {sql}");+ } else {+ assert_eq!(sql.matches("ADD COLUMN").count(), 2, "{db:?} two adds: {sql}");+ }}}@@ -13851,13 +14220,13 @@ mod tests {let changed_literal_whitespace ="CREATE VIEW `target_db`.`active_orders` AS SELECT 'source_db.orders', 'a b' FROM `target_db`.`orders`";- assert!(mysql_view_definitions_differ(+ assert!(view_definitions_differ(common,changed_schema_literal,Some(DialectKind::Mysql),Some(DialectKind::Mysql)));- assert!(mysql_view_definitions_differ(+ assert!(view_definitions_differ(common,changed_literal_whitespace,Some(DialectKind::Mysql),@@ -13870,7 +14239,7 @@ mod tests {let compact = "CREATE VIEW `app`.`active_orders` AS SELECT 1 <=> 1, 1 <= 2, 1 != 2";let split = "CREATE VIEW `app`.`active_orders` AS SELECT 1 < = > 1, 1 < = 2, 1 ! = 2";- assert!(mysql_view_definitions_differ(compact, split, Some(DialectKind::Mysql), Some(DialectKind::Mysql)));+ assert!(view_definitions_differ(compact, split, Some(DialectKind::Mysql), Some(DialectKind::Mysql)));}#[test]@@ -13883,7 +14252,7 @@ mod tests {ddl.replace("`OrderId`", "`orderid`"),ddl.replace("CASCADED", "LOCAL"),] {- assert!(mysql_view_definitions_differ(ddl, &changed, Some(DialectKind::Mysql), Some(DialectKind::Mysql)));+ assert!(view_definitions_differ(ddl, &changed, Some(DialectKind::Mysql), Some(DialectKind::Mysql)));}}@@ -14385,4 +14754,428 @@ mod tests {assert!(sql.contains("-- Create table: loop_a9761"), "{sql}");assert!(sql.contains("-- Create table: loop_b9761"), "{sql}");}++ fn typed_column(+ name: &str,+ data_type: &str,+ numeric_precision: Option<i32>,+ numeric_scale: Option<i32>,+ character_maximum_length: Option<i32>,+ ) -> ColumnInfo {+ ColumnInfo {+ is_nullable: true,+ numeric_precision,+ numeric_scale,+ character_maximum_length,+ ..column(name, data_type, None)+ }+ }++ fn named_index(name: &str, columns: &[&str], is_unique: bool) -> IndexInfo {+ index(IndexInfo {+ name: name.to_string(),+ columns: columns.iter().map(|column| (*column).to_string()).collect(),+ is_unique,+ is_primary: false,+ filter: None,+ index_type: Some("NORMAL".to_string()),+ included_columns: None,+ comment: None,+ key_is_expression: Vec::new(),+ column_opclasses: Vec::new(),+ key_options: Vec::new(),+ constraint_backed: false,+ })+ }++ fn oracle_table_pair(+ columns: Vec<ColumnInfo>,+ source_indexes: Vec<IndexInfo>,+ target_indexes: Vec<IndexInfo>,+ ) -> SchemaDiffPreparationOptions {+ SchemaDiffPreparationOptions {+ source_tables: vec![table_info("cmp_autoname", "TABLE")],+ target_tables: vec![table_info("cmp_autoname", "TABLE")],+ source_details: vec![TableSchemaDetail {+ name: "cmp_autoname".to_string(),+ columns: columns.clone(),+ indexes: source_indexes,+ foreign_keys: Vec::new(),+ triggers: Vec::new(),+ ddl: None,+ }],+ target_details: vec![TableSchemaDetail {+ name: "cmp_autoname".to_string(),+ columns,+ indexes: target_indexes,+ foreign_keys: Vec::new(),+ triggers: Vec::new(),+ ddl: None,+ }],+ database_type: DatabaseType::Oracle,+ ..Default::default()+ }+ }++ fn single_column_table_pair(source_column: ColumnInfo, target_column: ColumnInfo) -> SchemaDiffPreparationOptions {+ SchemaDiffPreparationOptions {+ source_tables: vec![table_info("cmp_autoname", "TABLE")],+ target_tables: vec![table_info("cmp_autoname", "TABLE")],+ source_details: vec![TableSchemaDetail {+ name: "cmp_autoname".to_string(),+ columns: vec![source_column],+ indexes: Vec::new(),+ foreign_keys: Vec::new(),+ triggers: Vec::new(),+ ddl: None,+ }],+ target_details: vec![TableSchemaDetail {+ name: "cmp_autoname".to_string(),+ columns: vec![target_column],+ indexes: Vec::new(),+ foreign_keys: Vec::new(),+ triggers: Vec::new(),+ ddl: None,+ }],+ database_type: DatabaseType::Oracle,+ ..Default::default()+ }+ }++ /// #9261:Oracle 给未命名的 PRIMARY KEY/UNIQUE 约束自动取的索引名(`SYS_C<编号>`)+ /// 是对象级的,两张结构完全相同的表也必然不同。按签名配对后不能再报出这对凭空+ /// 多出/消失的索引。+ #[test]+ fn server_generated_index_names_do_not_report_index_churn() {+ let result = prepare_schema_diff(oracle_table_pair(+ vec![+ typed_column("id", "NUMBER", Some(10), Some(0), Some(0)),+ typed_column("code", "VARCHAR2", None, None, Some(20)),+ ],+ vec![named_index("SYS_C008146", &["code"], true)],+ vec![named_index("SYS_C008149", &["code"], true)],+ ));++ assert!(result.diffs.is_empty(), "{:?}", result.diffs);+ }++ /// 兜底只覆盖「服务器自己命名」的索引:用户命名的索引改名仍然要报出来。+ #[test]+ fn differently_named_user_indexes_still_report_index_churn() {+ let result = prepare_schema_diff(oracle_table_pair(+ vec![typed_column("code", "VARCHAR2", None, None, Some(20))],+ vec![named_index("IDX_CODE", &["code"], false)],+ vec![named_index("IDX_CODE_OLD", &["code"], false)],+ ));++ assert_eq!(result.diffs.len(), 1, "{:?}", result.diffs);+ let indexes = result.diffs[0].indexes.as_ref().expect("index diff");+ assert_eq!(indexes.len(), 2, "{indexes:?}");+ assert!(indexes.iter().any(|diff| diff.diff_type == "added" && diff.name == "IDX_CODE"));+ assert!(indexes.iter().any(|diff| diff.diff_type == "removed" && diff.name == "IDX_CODE_OLD"));+ }++ /// 名字是服务器生成的、但定义不同(列不一样),必须仍然报差异。+ #[test]+ fn server_generated_index_with_a_different_definition_is_still_a_difference() {+ let result = prepare_schema_diff(oracle_table_pair(+ vec![+ typed_column("code", "VARCHAR2", None, None, Some(20)),+ typed_column("other_code", "VARCHAR2", None, None, Some(20)),+ ],+ vec![named_index("SYS_C008146", &["code"], true)],+ vec![named_index("SYS_C008149", &["other_code"], true)],+ ));++ assert_eq!(result.diffs.len(), 1, "{:?}", result.diffs);+ assert!(result.diffs[0].indexes.as_ref().is_some_and(|indexes| indexes.len() == 2));+ }++ /// #9261:Oracle 报的 `NUMBER` 不带精度,`NUMBER(10,2)` 与 `NUMBER(12,2)` 的类型串+ /// 一模一样,差别只在 data_precision/data_scale 里 —— 必须能比较出来。+ #[test]+ fn reported_numeric_precision_changes_are_detected() {+ let result = prepare_schema_diff(single_column_table_pair(+ typed_column("amt", "NUMBER", Some(10), Some(2), Some(0)),+ typed_column("amt", "NUMBER", Some(12), Some(2), Some(0)),+ ));++ assert_eq!(result.diffs.len(), 1, "{:?}", result.diffs);+ let columns = result.diffs[0].columns.as_ref().expect("column diff");+ assert_eq!(columns.len(), 1);+ assert_eq!(columns[0].changes, vec!["type: NUMBER(12,2) → NUMBER(10,2)".to_string()]);+ }++ /// 字符长度同理:驱动把它放在 character_maximum_length 里。+ #[test]+ fn reported_character_length_changes_are_detected() {+ let result = prepare_schema_diff(single_column_table_pair(+ typed_column("name", "VARCHAR2", None, None, Some(40)),+ typed_column("name", "VARCHAR2", None, None, Some(20)),+ ));++ assert_eq!(result.diffs.len(), 1, "{:?}", result.diffs);+ let columns = result.diffs[0].columns.as_ref().expect("column diff");+ assert_eq!(columns[0].changes, vec!["type: VARCHAR2(20) → VARCHAR2(40)".to_string()]);+ }++ /// 驱动根本没报精度/长度时不能臆造差异(两侧都为空 => 相等)。+ #[test]+ fn columns_without_reported_parameters_do_not_invent_a_difference() {+ let result = prepare_schema_diff(single_column_table_pair(+ typed_column("amt", "NUMBER", None, None, None),+ typed_column("amt", "NUMBER", None, None, None),+ ));++ assert!(result.diffs.is_empty(), "{:?}", result.diffs);+ }++ /// MySQL 的 `int` 也会带 numeric_precision,但 `int(10)` 不是它的声明类型(跨方言会+ /// 变成非法 DDL),所以整数族不在拼接白名单里。+ #[test]+ fn integer_precision_metadata_is_not_spliced_into_the_type() {+ let result = prepare_schema_diff(SchemaDiffPreparationOptions {+ source_tables: vec![table_info("t", "TABLE")],+ target_tables: vec![table_info("t", "TABLE")],+ source_details: vec![TableSchemaDetail {+ name: "t".to_string(),+ columns: vec![typed_column("id", "int", Some(10), Some(0), None)],+ indexes: Vec::new(),+ foreign_keys: Vec::new(),+ triggers: Vec::new(),+ ddl: None,+ }],+ target_details: vec![TableSchemaDetail {+ name: "t".to_string(),+ columns: vec![typed_column("id", "int", Some(10), Some(0), None)],+ indexes: Vec::new(),+ foreign_keys: Vec::new(),+ triggers: Vec::new(),+ ddl: None,+ }],+ database_type: DatabaseType::Mysql,+ ..Default::default()+ });++ assert!(result.diffs.is_empty(), "{:?}", result.diffs);+ assert_eq!(declared_column_type(&typed_column("id", "int", Some(10), Some(0), None)), "int");+ }++ fn oracle_column(+ name: &str,+ data_type: &str,+ numeric_precision: Option<i32>,+ numeric_scale: Option<i32>,+ character_maximum_length: Option<i32>,+ is_nullable: bool,+ column_default: Option<&str>,+ ) -> ColumnInfo {+ ColumnInfo {+ is_nullable,+ column_default: column_default.map(str::to_string),+ ..typed_column(name, data_type, numeric_precision, numeric_scale, character_maximum_length)+ }+ }++ fn oracle_column_pair(source: Vec<ColumnInfo>, target: Vec<ColumnInfo>) -> SchemaDiffPreparationOptions {+ SchemaDiffPreparationOptions {+ source_tables: vec![table_info("cmp_grammar", "TABLE")],+ target_tables: vec![table_info("cmp_grammar", "TABLE")],+ source_details: vec![TableSchemaDetail {+ name: "cmp_grammar".to_string(),+ columns: source,+ indexes: Vec::new(),+ foreign_keys: Vec::new(),+ triggers: Vec::new(),+ ddl: None,+ }],+ target_details: vec![TableSchemaDetail {+ name: "cmp_grammar".to_string(),+ columns: target,+ indexes: Vec::new(),+ foreign_keys: Vec::new(),+ triggers: Vec::new(),+ ddl: None,+ }],+ database_type: DatabaseType::Oracle,+ source_dialect: Some(DialectKind::Oracle),+ target_dialect: Some(DialectKind::Oracle),+ ..Default::default()+ }+ }++ /// Oracle 没有 `ADD COLUMN`/`MODIFY COLUMN`,列变更子句要写成 `ADD (定义)` /+ /// `MODIFY (定义)`;定义内部 `DEFAULT` 又必须排在 `NOT NULL` 前面,否则 11g 直接+ /// 报 ORA-00907(都是真机实测过的语法)。+ #[test]+ fn oracle_column_clauses_follow_the_oracle_grammar() {+ let result = prepare_schema_diff(oracle_column_pair(+ vec![+ oracle_column("amt", "NUMBER", Some(12), Some(2), Some(0), false, None),+ oracle_column("label", "VARCHAR2", None, None, Some(20), false, Some("'x'")),+ ],+ vec![oracle_column("amt", "NUMBER", Some(10), Some(2), Some(0), false, None)],+ ));++ let sql = result.sync_sql;+ assert!(sql.contains("ADD (LABEL VARCHAR2(20) DEFAULT 'x' NOT NULL)"), "{sql}");+ assert!(sql.contains("MODIFY (AMT NUMBER(12,2) NOT NULL)"), "{sql}");+ assert!(!sql.contains("ADD COLUMN"), "{sql}");+ assert!(!sql.contains("MODIFY COLUMN"), "{sql}");+ assert!(!sql.contains("ALTER COLUMN"), "{sql}");+ let add = sql.lines().find(|line| line.contains("ADD (")).expect("ADD clause");+ let default_at = add.find("DEFAULT").expect("default literal");+ let not_null_at = add.find("NOT NULL").expect("not null");+ assert!(default_at < not_null_at, "DEFAULT must precede NOT NULL: {sql}");+ }++ /// 把列改成可空时,Oracle 重述定义的 `MODIFY (列 定义)` **不会**去掉已有的+ /// `NOT NULL`(11g 实测),所以生成的语句必须显式写 `NULL`,否则脚本报成功但约束还在。+ #[test]+ fn oracle_modify_spells_null_when_dropping_not_null() {+ let with_type_change = prepare_schema_diff(oracle_column_pair(+ vec![oracle_column("amt", "NUMBER", Some(12), Some(2), Some(0), true, None)],+ vec![oracle_column("amt", "NUMBER", Some(10), Some(2), Some(0), false, None)],+ ));+ let sql = with_type_change.sync_sql;+ assert!(sql.contains("MODIFY (AMT NUMBER(12,2) NULL)"), "{sql}");+ assert!(!sql.contains("NOT NULL"), "{sql}");++ let nullability_only = prepare_schema_diff(oracle_column_pair(+ vec![oracle_column("amt", "NUMBER", Some(10), Some(2), Some(0), true, None)],+ vec![oracle_column("amt", "NUMBER", Some(10), Some(2), Some(0), false, None)],+ ));+ let sql = nullability_only.sync_sql;+ assert!(sql.contains("MODIFY (AMT NUMBER(10,2) NULL)"), "{sql}");+ }++ fn oracle_view_options(source_ddl: Option<&str>, target_ddl: Option<&str>) -> SchemaDiffPreparationOptions {+ SchemaDiffPreparationOptions {+ source_tables: vec![table_info("v_change", "VIEW")],+ target_tables: vec![table_info("v_change", "VIEW")],+ source_details: vec![schema_detail("v_change", source_ddl)],+ target_details: vec![schema_detail("v_change", target_ddl)],+ database_type: DatabaseType::Oracle,+ source_dialect: Some(DialectKind::Oracle),+ target_dialect: Some(DialectKind::Oracle),+ ..Default::default()+ }+ }++ /// #9261:`DBMS_METADATA` 抓到的 Oracle 视图文本里 owner 出现在头部+ /// (`CREATE OR REPLACE FORCE VIEW "DBX_TEST"."V_SAME"`)和每一处限定名上,两张不同+ /// schema 的**同一张**视图必然处处不同 —— 归一化 owner 之后不能再报差异。+ #[test]+ fn oracle_views_with_different_owners_compare_equal() {+ let result = prepare_schema_diff(oracle_view_options(+ Some(+ "CREATE OR REPLACE FORCE VIEW \"DBX_TEST\".\"V_SAME\" (\"ID\", \"NAME\", \"AMT\") AS\n SELECT ID, NAME, AMT FROM DBX_TEST.CMP_SAME;",+ ),+ Some(+ "CREATE OR REPLACE FORCE VIEW \"DBX_TGT\".\"V_SAME\" (\"ID\",\"NAME\",\"AMT\") AS\n SELECT ID,\n NAME,\n AMT\n FROM DBX_TGT.CMP_SAME",+ ),+ ));++ assert!(result.diffs.is_empty(), "{:?}", result.diffs);+ }++ /// 真正不同(列少了、条件不同)的视图仍然要报出来。+ #[test]+ fn oracle_views_with_a_different_definition_are_reported() {+ let result = prepare_schema_diff(oracle_view_options(+ Some(+ "CREATE OR REPLACE FORCE VIEW \"DBX_TEST\".\"V_CHANGE\" (\"ID\", \"NAME\", \"AMT\") AS\n SELECT ID, NAME, AMT FROM DBX_TEST.CMP_SAME;",+ ),+ Some(+ "CREATE OR REPLACE FORCE VIEW \"DBX_TGT\".\"V_CHANGE\" (\"ID\", \"NAME\") AS\n SELECT ID, NAME FROM DBX_TGT.CMP_SAME;",+ ),+ ));++ assert_eq!(result.diffs.len(), 1, "{:?}", result.diffs);+ assert_eq!(result.diffs[0].object_type.as_deref(), Some("view"));+ assert_eq!(result.diffs[0].diff_type, "modified");+ }++ /// 字符串字面量里的 `'DBX_TEST.CMP_SAME'` 不是限定名:归一化只改 owner 的限定引用,+ /// 字面量原样保留 —— 所以两侧字面量不同时,视图仍然算不同。+ #[test]+ fn oracle_view_owner_normalization_leaves_literals_alone() {+ let source = "CREATE OR REPLACE FORCE VIEW \"DBX_TEST\".\"V_LIT\" AS SELECT 'DBX_TEST.CMP_SAME' AS TAG, ID FROM DBX_TEST.CMP_SAME";+ let target = "CREATE OR REPLACE FORCE VIEW \"DBX_TGT\".\"V_LIT\" AS SELECT 'DBX_TEST.CMP_SAME' AS TAG, ID FROM DBX_TGT.CMP_SAME";++ let normalized = normalize_oracle_view_ddl(source);+ // 只有头部 owner 和 `FROM` 后面的限定名被替换,字面量原样保留。+ assert!(normalized.contains("'DBX_TEST.CMP_SAME' AS TAG"), "{normalized}");+ assert_eq!(normalized.matches("__dbx_schema__").count(), 2, "{normalized}");+ assert_eq!(normalized, normalize_oracle_view_ddl(target), "{normalized}");++ // 字面量真的不一样时仍然是差异(说明字面量没有被一起改写掉)。+ let changed_literal = target.replace("'DBX_TEST.CMP_SAME' AS TAG", "'DBX_TGT.CMP_SAME' AS TAG");+ assert_ne!(normalized, normalize_oracle_view_ddl(&changed_literal));+ }++ /// dbx 自己生成的脚本只改写视图头,落库后目标视图的正文可能仍限定源 schema;这时两侧+ /// 必须判为相同,否则脚本执行完差异也不会消失。只有第三个 schema 的限定名才算差异。+ #[test]+ fn oracle_views_whose_body_keeps_the_other_schema_compare_equal() {+ let source =+ "CREATE OR REPLACE FORCE VIEW \"DBX_TEST\".\"V_NEW\" (\"ID\") AS \n select id from DBX_TEST.CMP_OK;";+ let target =+ "CREATE OR REPLACE FORCE VIEW \"DBX_TGT\".\"V_NEW\" (\"ID\") AS \n select id from DBX_TEST.CMP_OK;";+ let oracle = (Some(DialectKind::Oracle), Some(DialectKind::Oracle));+ assert!(!view_definitions_differ(source, target, oracle.0, oracle.1));++ // 目标侧按自己的 schema 写正文,同样不能算差异。+ let target_self = target.replace("from DBX_TEST.CMP_OK", "from DBX_TGT.CMP_OK");+ assert!(!view_definitions_differ(source, &target_self, oracle.0, oracle.1));++ // 第三个 schema 的限定名不在归一化范围内:正文确实不同时仍然报差异。+ let other_schema = target.replace("from DBX_TEST.CMP_OK", "from DBX_OTHER.CMP_OK");+ assert!(view_definitions_differ(source, &other_schema, oracle.0, oracle.1));+ let changed_body = target.replace("select id from", "select id, name from");+ assert!(view_definitions_differ(source, &changed_body, oracle.0, oracle.1));+ }++ /// 跨方言的视图文本本来就不是同一种 SQL,不参与比较。+ #[test]+ fn oracle_view_text_is_not_compared_across_dialects() {+ assert!(!view_definitions_differ(+ "CREATE OR REPLACE FORCE VIEW \"DBX_TEST\".\"V_SAME\" AS SELECT 1 FROM DUAL",+ "CREATE ALGORITHM=UNDEFINED VIEW `v_same` AS select 1",+ Some(DialectKind::Mysql),+ Some(DialectKind::Oracle),+ ));+ }++ /// Oracle 的视图头带 `FORCE`,生成的脚本要把它改写成目标 schema,否则会在源 schema+ /// 上建视图(或因为权限直接失败)。+ #[test]+ fn added_oracle_view_native_ddl_rewrites_source_schema_to_target_schema() {+ let diffs = vec![TableDiff {+ diff_type: "added".to_string(),+ object_type: Some("view".to_string()),+ name: "V_NEW".to_string(),+ ddl: Some(+ "CREATE OR REPLACE FORCE VIEW \"DBX_TEST\".\"V_NEW\" (\"ID\") AS\n SELECT ID FROM DBX_TEST.CMP_SAME"+ .to_string(),+ ),+ ..TableDiff::default()+ }];++ let sql = generate_schema_sync_sql(+ &diffs,+ &[],+ &[],+ &[],+ &[],+ DatabaseType::Oracle,+ Some("DBX_TGT"),+ false,+ Some(DialectKind::Oracle),+ &[],+ );++ assert!(sql.contains("CREATE OR REPLACE FORCE VIEW DBX_TGT.V_NEW"), "{sql}");+ assert!(!sql.contains("DBX_TEST.V_NEW"), "{sql}");+ }}diff --git a/crates/dbx-sql/src/sql_dialect/ddl_profile.rs b/crates/dbx-sql/src/sql_dialect/ddl_profile.rsindex 71f23e15d5..b96777bae7 100644--- a/crates/dbx-sql/src/sql_dialect/ddl_profile.rs+++ b/crates/dbx-sql/src/sql_dialect/ddl_profile.rs@@ -142,6 +142,17 @@ pub struct DdlDialectProfile {pub column_ddl: ColumnDdlSyntax,/// MySQL `MODIFY COLUMN` vs ANSI `ALTER COLUMN … TYPE/SET`.pub alter_uses_modify_column: bool,+ /// Spell `ADD COLUMN` (MySQL/Postgres/...) instead of the Oracle-family bare `ADD (...)`.+ pub add_column_uses_column_keyword: bool,+ /// Spell `MODIFY COLUMN` (MySQL) instead of the bare `MODIFY (...)` Oracle-family and+ /// Dameng both use.+ pub modify_column_uses_column_keyword: bool,+ /// Wrap the definition in parentheses: Oracle's `ADD (...)` / `MODIFY (...)` clauses.+ pub parenthesized_alter_column_clause: bool,+ /// Write `DEFAULT` before `NOT NULL`. Oracle's grammar is+ /// `datatype [DEFAULT expr] [NOT NULL]` and it rejects the MySQL order outright+ /// (ORA-00907), so the tail of a column definition is dialect data, not cosmetics.+ pub column_default_precedes_not_null: bool,/// Batch multiple alter clauses in one `ALTER TABLE` statement.pub alter_batches_clauses: bool,/// Prefer emitting source SHOW CREATE / native DDL when dialects match (MySQL-family).@@ -210,10 +221,33 @@ impl DdlDialectProfile {}pub fn alter_modify_keyword(&self) -> &'static str {- if self.database_type == DatabaseType::Dameng {+ if self.modify_column_uses_column_keyword {+ "MODIFY COLUMN"+ } else {"MODIFY"+ }+ }++ /// Clause that changes one column's type without restating the whole definition.+ ///+ /// `ALTER COLUMN x TYPE …` everywhere except the Oracle grammar, where `TYPE` does not+ /// exist and the change has to be spelled `MODIFY (x TYPE)`.+ pub fn alter_column_type_clause(&self, name: &str, data_type: &str) -> String {+ if self.parenthesized_alter_column_clause {+ format!(" {} ({name} {data_type})", self.alter_modify_keyword())} else {- "MODIFY COLUMN"+ format!(" ALTER COLUMN {name} TYPE {data_type}")+ }+ }++ /// Clause that flips one column's nullability, in the dialect's spelling.+ pub fn alter_column_nullability_clause(&self, name: &str, nullable: bool) -> String {+ if self.parenthesized_alter_column_clause {+ format!(" {} ({name} {})", self.alter_modify_keyword(), if nullable { "NULL" } else { "NOT NULL" })+ } else if nullable {+ format!(" ALTER COLUMN {name} DROP NOT NULL")+ } else {+ format!(" ALTER COLUMN {name} SET NOT NULL")}}@@ -361,6 +395,10 @@ fn mysql_family(db: DatabaseType) -> DdlDialectProfile {grant_uses_mysql_user_syntax: true,warn_fk_needs_table_rebuild: false,alter_uses_modify_column: true,+ add_column_uses_column_keyword: true,+ modify_column_uses_column_keyword: true,+ parenthesized_alter_column_clause: false,+ column_default_precedes_not_null: false,alter_batches_clauses: true,create_table_if_not_exists: true,create_index_if_not_exists: false,@@ -410,6 +448,10 @@ fn postgres_family(db: DatabaseType) -> DdlDialectProfile {grant_uses_mysql_user_syntax: false,warn_fk_needs_table_rebuild: false,alter_uses_modify_column: false,+ add_column_uses_column_keyword: true,+ modify_column_uses_column_keyword: true,+ parenthesized_alter_column_clause: false,+ column_default_precedes_not_null: false,alter_batches_clauses: false,create_table_if_not_exists: false,create_index_if_not_exists: true,@@ -463,6 +505,16 @@ fn oracle_family(db: DatabaseType) -> DdlDialectProfile {grant_uses_mysql_user_syntax: false,warn_fk_needs_table_rebuild: false,alter_uses_modify_column: false,+ // Family defaults keep the spellings the rest of the family had before+ // (`ADD COLUMN`, bare `MODIFY`); `profile_for` turns on the Oracle-specific+ // clause shapes for the engines whose grammar was verified on a real instance.+ add_column_uses_column_keyword: true,+ modify_column_uses_column_keyword: false,+ // `profile_for` turns both of these on for the engines whose Oracle grammar is+ // exercised by tests and real instances (`Oracle`, `OceanbaseOracle`); the rest+ // of the family keeps the spellings they had before.+ parenthesized_alter_column_clause: false,+ column_default_precedes_not_null: false,alter_batches_clauses: false,create_table_if_not_exists: false,create_index_if_not_exists: false,@@ -514,6 +566,10 @@ fn sqlserver_family(db: DatabaseType) -> DdlDialectProfile {grant_uses_mysql_user_syntax: false,warn_fk_needs_table_rebuild: false,alter_uses_modify_column: false,+ add_column_uses_column_keyword: true,+ modify_column_uses_column_keyword: true,+ parenthesized_alter_column_clause: false,+ column_default_precedes_not_null: false,alter_batches_clauses: false,create_table_if_not_exists: false,create_index_if_not_exists: false,@@ -563,6 +619,10 @@ fn sqlite_family(db: DatabaseType) -> DdlDialectProfile {grant_uses_mysql_user_syntax: false,warn_fk_needs_table_rebuild: true,alter_uses_modify_column: false,+ add_column_uses_column_keyword: true,+ modify_column_uses_column_keyword: true,+ parenthesized_alter_column_clause: false,+ column_default_precedes_not_null: false,alter_batches_clauses: false,create_table_if_not_exists: true,create_index_if_not_exists: true,@@ -613,6 +673,10 @@ fn access_profile() -> DdlDialectProfile {grant_uses_mysql_user_syntax: false,warn_fk_needs_table_rebuild: false,alter_uses_modify_column: false,+ add_column_uses_column_keyword: true,+ modify_column_uses_column_keyword: true,+ parenthesized_alter_column_clause: false,+ column_default_precedes_not_null: false,alter_batches_clauses: false,create_table_if_not_exists: false,create_index_if_not_exists: false,@@ -664,6 +728,10 @@ fn h2_profile() -> DdlDialectProfile {grant_uses_mysql_user_syntax: false,warn_fk_needs_table_rebuild: false,alter_uses_modify_column: false,+ add_column_uses_column_keyword: true,+ modify_column_uses_column_keyword: true,+ parenthesized_alter_column_clause: false,+ column_default_precedes_not_null: false,alter_batches_clauses: false,create_table_if_not_exists: false,create_index_if_not_exists: false,@@ -720,6 +788,10 @@ fn conservative_ansi(db: DatabaseType) -> DdlDialectProfile {grant_uses_mysql_user_syntax: false,warn_fk_needs_table_rebuild: false,alter_uses_modify_column: false,+ add_column_uses_column_keyword: true,+ modify_column_uses_column_keyword: true,+ parenthesized_alter_column_clause: false,+ column_default_precedes_not_null: false,alter_batches_clauses: false,create_table_if_not_exists: false,create_index_if_not_exists: false,@@ -788,8 +860,19 @@ pub fn profile_for(db_type: DatabaseType) -> DdlDialectProfile {profile}- // Oracle family- Oracle | OceanbaseOracle | Yashandb | Xugu | Iris => oracle_family(db_type),+ // Oracle family. Oracle itself (and OceanBase's Oracle-compatibility mode) needs+ // the Oracle clause spelling everywhere: `ADD (…)` / `MODIFY (….)`, and `DEFAULT`+ // ahead of `NOT NULL`. The remaining family members keep the previous spellings+ // until their own grammar is verified against a real instance.+ Oracle | OceanbaseOracle => {+ let mut profile = oracle_family(db_type);+ profile.add_column_uses_column_keyword = false;+ profile.parenthesized_alter_column_clause = true;+ profile.column_default_precedes_not_null = true;+ profile+ }++ Yashandb | Xugu | Iris => oracle_family(db_type),// SQL Server (not Access)SqlServer => sqlserver_family(db_type),