Skip to content

armgit / dbx

Public Imported from GitHub
0

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。

feat(types): add Oracle-family type management and dependency migration

efeire6889aaff5341
diff --git a/agents/drivers/dameng/src/main/java/com/dbx/agent/dameng/DamengAgent.java b/agents/drivers/dameng/src/main/java/com/dbx/agent/dameng/DamengAgent.java
index 991e361d45..3fce6645c9 100644
--- a/agents/drivers/dameng/src/main/java/com/dbx/agent/dameng/DamengAgent.java
+++ b/agents/drivers/dameng/src/main/java/com/dbx/agent/dameng/DamengAgent.java
@@ -997,7 +997,9 @@ public final class DamengAgent extends AbstractJdbcAgent {
|| constraints.objectTypeAllowed("FUNCTION")
|| constraints.objectTypeAllowed("SEQUENCE")
|| constraints.objectTypeAllowed("PACKAGE")
- || constraints.objectTypeAllowed("PACKAGE_BODY");
+ || constraints.objectTypeAllowed("PACKAGE_BODY")
+ || constraints.objectTypeAllowed("TYPE")
+ || constraints.objectTypeAllowed("TYPE_BODY");
}
private static void appendDamengObjectTypePredicate(
@@ -1048,6 +1050,12 @@ public final class DamengAgent extends AbstractJdbcAgent {
if (constraints.objectTypeAllowed("PACKAGE_BODY")) {
result.add("PACKAGE BODY");
}
+ if (constraints.objectTypeAllowed("TYPE")) {
+ result.add("TYPE");
+ }
+ if (constraints.objectTypeAllowed("TYPE_BODY")) {
+ result.add("TYPE BODY");
+ }
return result;
}
@@ -1082,6 +1090,12 @@ public final class DamengAgent extends AbstractJdbcAgent {
if (constraints.objectTypeAllowed("PACKAGE_BODY")) {
result.add("PACKAGE BODY");
}
+ if (constraints.objectTypeAllowed("TYPE")) {
+ result.add("TYPE");
+ }
+ if (constraints.objectTypeAllowed("TYPE_BODY")) {
+ result.add("TYPE BODY");
+ }
return result;
}
@@ -1484,7 +1498,11 @@ public final class DamengAgent extends AbstractJdbcAgent {
RuntimeException dbmsError;
try {
String source = readDbmsMetadataObjectSource(dbmsType, name, schema);
- return new ObjectSource(name, objectType, schema, source);
+ if (isOracleFamilyType(objectType) && !notBlank(source)) {
+ dbmsError = new IllegalStateException("DM8 returned empty type source for " + schema + "." + name);
+ } else {
+ return new ObjectSource(name, objectType, schema, source, !isOracleFamilyType(objectType));
+ }
} catch (Exception error) {
// 检查型异常(SQLException 等)由 unchecked 透传后在此处统一处理。
RuntimeException runtimeError = error instanceof RuntimeException runtime ? runtime : new RuntimeException(error);
@@ -1494,7 +1512,14 @@ public final class DamengAgent extends AbstractJdbcAgent {
dbmsError = runtimeError;
}
try {
- return buildCatalogObjectSource(schema, name, objectType, dbmsError);
+ ObjectSource source = buildCatalogObjectSource(schema, name, objectType, dbmsError);
+ if (isOracleFamilyType(objectType)) {
+ if (source == null || !notBlank(source.getSource()) || source.getSource().startsWith(CATALOG_BODY_HINT)) {
+ throw new IllegalStateException("DM8 could not read complete type source for " + schema + "." + name, dbmsError);
+ }
+ return new ObjectSource(name, objectType, schema, source.getSource(), false);
+ }
+ return source;
} catch (RuntimeException fallbackError) {
fallbackError.addSuppressed(dbmsError);
throw fallbackError;
@@ -1502,6 +1527,11 @@ public final class DamengAgent extends AbstractJdbcAgent {
});
}
+ private static boolean isOracleFamilyType(String objectType) {
+ String normalized = normalizeObjectSourceType(objectType);
+ return "TYPE".equals(normalized) || "TYPE_BODY".equals(normalized);
+ }
+
private String readDbmsMetadataObjectSource(String dbmsType, String name, String schema) throws Exception {
String sql = "SELECT /*+ PARALLEL(1) */ DBMS_METADATA.GET_DDL(?, ?, ?) FROM DUAL";
try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
@@ -1578,6 +1608,9 @@ public final class DamengAgent extends AbstractJdbcAgent {
}
default -> throw new IllegalArgumentException("Unsupported object type: " + objectType);
}
+ if (isOracleFamilyType(objectType)) {
+ throw new IllegalStateException("DM8 could not read complete type source for " + schema + "." + name + " (" + objectType + ")", dbmsError);
+ }
return unavailableObjectSource(schema, name, objectType, dbmsError);
}
@@ -1715,6 +1748,9 @@ public final class DamengAgent extends AbstractJdbcAgent {
String sourceType,
String source
) {
+ if (isOracleFamilyType(objectType)) {
+ return oracleFamilyTypeSourceMatches(source, objectType);
+ }
if (!("FUNCTION".equals(objectType) || "PROCEDURE".equals(objectType))
|| !"PROC".equalsIgnoreCase(sourceType)) {
return true;
@@ -1725,6 +1761,30 @@ public final class DamengAgent extends AbstractJdbcAgent {
: routineSourceStartsWithType(source, objectType);
}
+ private static boolean oracleFamilyTypeSourceMatches(String source, String objectType) {
+ String expected = "TYPE_BODY".equals(normalizeObjectSourceType(objectType)) ? "TYPE BODY" : "TYPE";
+ String firstDeclaration = oracleFamilyTypeDeclaration(source.stripLeading());
+ return expected.equals(firstDeclaration);
+ }
+
+ private static String oracleFamilyTypeDeclaration(String source) {
+ String candidate = stripTypeDdlPrefix(source);
+ if (startsWithRoutineDeclaration(candidate, "TYPE BODY")) {
+ return "TYPE BODY";
+ }
+ return startsWithRoutineDeclaration(candidate, "TYPE") ? "TYPE" : "";
+ }
+
+ private static String stripTypeDdlPrefix(String source) {
+ String upper = source.toUpperCase(Locale.ROOT);
+ for (String prefix : List.of("CREATE OR REPLACE ", "CREATE ", "ALTER ")) {
+ if (upper.startsWith(prefix)) {
+ return source.substring(prefix.length()).stripLeading();
+ }
+ }
+ return source;
+ }
+
private String readDamengRoutineObjectType(String schema, String name) {
String sql = """
SELECT o.INFO1
@@ -1808,12 +1868,20 @@ public final class DamengAgent extends AbstractJdbcAgent {
JOIN SYS.SYSOBJECTS o ON o.ID = t.ID
JOIN SYS.SYSOBJECTS s ON s.ID = o.SCHID AND s.TYPE$ = 'SCH' AND s.NAME = ?
WHERE o.NAME = ?
- ORDER BY t.SEQNO
""".stripIndent().trim();
+ boolean typedType = isOracleFamilyType(objectType);
+ if (typedType) {
+ sql += " AND EXISTS (SELECT 1 FROM ALL_OBJECTS a WHERE a.OBJECT_ID = o.ID"
+ + " AND a.OWNER = s.NAME AND a.OBJECT_NAME = o.NAME AND a.OBJECT_TYPE = ?)";
+ }
+ sql += " ORDER BY t.SEQNO";
StringBuilder source = new StringBuilder();
try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
stmt.setString(1, schema);
stmt.setString(2, name);
+ if (typedType) {
+ stmt.setString(3, "TYPE_BODY".equals(normalizeObjectSourceType(objectType)) ? "TYPE BODY" : "TYPE");
+ }
try (ResultSet rs = stmt.executeQuery()) {
while (rs.next()) {
String line = coalesce(readTextColumn(rs, 1));
diff --git a/agents/drivers/dameng/src/test/java/com/dbx/agent/dameng/DamengAgentMetadataTest.java b/agents/drivers/dameng/src/test/java/com/dbx/agent/dameng/DamengAgentMetadataTest.java
index 7a81251f1a..0ca3fdf125 100644
--- a/agents/drivers/dameng/src/test/java/com/dbx/agent/dameng/DamengAgentMetadataTest.java
+++ b/agents/drivers/dameng/src/test/java/com/dbx/agent/dameng/DamengAgentMetadataTest.java
@@ -1400,10 +1400,112 @@ class DamengAgentMetadataTest {
ObjectSource source = agent.getObjectSource("APP", "T_ADDR", "TYPE");
Assertions.assertTrue(source.getSource().contains("CREATE OR REPLACE TYPE"), source.getSource());
- Assertions.assertTrue(source.isEditable());
+ Assertions.assertFalse(source.isEditable());
Assertions.assertTrue(sqls.stream().anyMatch(sql -> sql.contains("FROM ALL_SOURCE")), String.join("\n", sqls));
}
+ @Test
+ void fallsBackToCompleteCatalogSourceWhenGetDdlReturnsNullOrBlank() {
+ for (String emptyDdl : Arrays.asList(null, "", " ")) {
+ for (String objectType : List.of("TYPE", "TYPE_BODY")) {
+ String declaration = "TYPE_BODY".equals(objectType) ? "TYPE BODY" : "TYPE";
+ DamengAgent agent = new DamengAgent();
+ List<String> sqls = new ArrayList<>();
+ TestSupport.setPrivateConnection(agent, getDdlResultWithCatalogConnection(
+ sqls,
+ emptyDdl,
+ List.of(List.of("CREATE OR REPLACE " + declaration + " \"APP\".\"T_ADDR\" AS"),
+ List.of(" CITY VARCHAR2(64)"), List.of("END;"))
+ ));
+
+ ObjectSource source = agent.getObjectSource("APP", "T_ADDR", objectType);
+
+ Assertions.assertTrue(source.getSource().startsWith("CREATE OR REPLACE " + declaration), source.getSource());
+ Assertions.assertFalse(source.isEditable());
+ Assertions.assertTrue(sqls.stream().anyMatch(sql -> sql.contains("FROM ALL_SOURCE")), String.join("\n", sqls));
+ }
+ }
+
+ DamengAgent noCatalogAgent = new DamengAgent();
+ TestSupport.setPrivateConnection(noCatalogAgent,
+ getDdlResultWithCatalogConnection(new ArrayList<>(), "", List.of()));
+ Assertions.assertThrows(RuntimeException.class,
+ () -> noCatalogAgent.getObjectSource("APP", "T_ADDR", "TYPE"));
+ }
+
+ @Test
+ void returnsTypeBodySourceOnlyForTypeBodyAndTypeSourceOnlyForType() {
+ for (String[] requestedAndDeclaration : List.of(
+ new String[] {"TYPE", "CREATE OR REPLACE TYPE \"APP\".\"T_ADDR\" AS OBJECT (CITY VARCHAR2(64));"},
+ new String[] {"TYPE_BODY", "\nCREATE OR REPLACE TYPE BODY \"APP\".\"T_ADDR\" AS MEMBER FUNCTION CITY_NAME RETURN VARCHAR2 IS\n TYPE local_items IS TABLE OF NUMBER;\n /* Example text, not a second type:\n CREATE TYPE demo AS OBJECT (n NUMBER);\n */\n v_example VARCHAR2(100) := q'!CREATE TYPE demo AS OBJECT (\nn NUMBER);!';\n BEGIN RETURN 'X'; END; END;"}
+ )) {
+ DamengAgent agent = new DamengAgent();
+ TestSupport.setPrivateConnection(agent, catalogFallbackConnection(
+ missingDbmsMetadataPackageError(), new ArrayList<>(),
+ List.of(List.of(requestedAndDeclaration[1])), null, List.of(), null));
+
+ ObjectSource source = agent.getObjectSource("APP", "T_ADDR", requestedAndDeclaration[0]);
+
+ Assertions.assertTrue(source.getSource().startsWith("CREATE OR REPLACE " + ("TYPE_BODY".equals(requestedAndDeclaration[0]) ? "TYPE BODY" : "TYPE")), source.getSource());
+ if ("TYPE_BODY".equals(requestedAndDeclaration[0])) {
+ Assertions.assertTrue(source.getSource().contains("TYPE local_items IS TABLE OF NUMBER"), source.getSource());
+ Assertions.assertTrue(source.getSource().contains("CREATE TYPE demo AS OBJECT"), source.getSource());
+ Assertions.assertTrue(source.getSource().contains("q'!CREATE TYPE demo AS OBJECT"), source.getSource());
+ }
+ Assertions.assertFalse(source.isEditable());
+ }
+ }
+
+ @Test
+ void rejectsWrongTypeHeadersAndBindsSystemTextLookupToExactTypeCategory() {
+ String typeDdl = "CREATE OR REPLACE TYPE \"APP\".\"T_ADDR\" AS OBJECT (CITY VARCHAR2(64));";
+ String typeBodyDdl = "CREATE OR REPLACE TYPE BODY \"APP\".\"T_ADDR\" AS MEMBER FUNCTION CITY_NAME RETURN VARCHAR2 IS BEGIN RETURN 'X'; END; END;";
+ for (String[] requestedAndWrongSource : List.of(
+ new String[] {"TYPE_BODY", typeDdl},
+ new String[] {"TYPE", typeBodyDdl}
+ )) {
+ DamengAgent agent = new DamengAgent();
+ List<String> sqls = new ArrayList<>();
+ List<String> boundValues = new ArrayList<>();
+ TestSupport.setPrivateConnection(agent, catalogFallbackConnection(
+ missingDbmsMetadataPackageError(), sqls, List.of(), missingCatalogViewError("ALL_SOURCE"),
+ List.of(List.of(requestedAndWrongSource[1])), null, boundValues));
+
+ Assertions.assertThrows(RuntimeException.class,
+ () -> agent.getObjectSource("APP", "T_ADDR", requestedAndWrongSource[0]));
+ String query = sqls.stream().filter(sql -> sql.contains("SYS.SYSTEXTS")).findFirst().orElseThrow();
+ Assertions.assertTrue(query.contains("a.OBJECT_ID = o.ID"), query);
+ Assertions.assertTrue(query.contains("a.OWNER = s.NAME AND a.OBJECT_NAME = o.NAME"), query);
+ Assertions.assertTrue(query.contains("a.OBJECT_TYPE = ?"), query);
+ Assertions.assertEquals(List.of("APP", "T_ADDR", "TYPE_BODY".equals(requestedAndWrongSource[0])
+ ? "TYPE BODY" : "TYPE"), boundValues);
+ }
+ }
+
+ @Test
+ void readsCorrectTypeBodyFromSystemTextsFallback() {
+ String typeBodyDdl = "\nTYPE BODY \"APP\".\"T_ADDR\" AS MEMBER FUNCTION CITY_NAME RETURN VARCHAR2 IS\n TYPE local_items IS TABLE OF NUMBER;\n /* Example text, not a second type:\n CREATE TYPE demo AS OBJECT (n NUMBER);\n */\n v_example VARCHAR2(100) := q'!CREATE TYPE demo AS OBJECT (\nn NUMBER);!';\n BEGIN RETURN 'X'; END; END;";
+ DamengAgent agent = new DamengAgent();
+ List<String> sqls = new ArrayList<>();
+ List<String> boundValues = new ArrayList<>();
+ TestSupport.setPrivateConnection(agent, catalogFallbackConnection(
+ missingDbmsMetadataPackageError(), sqls, List.of(), missingCatalogViewError("ALL_SOURCE"),
+ List.of(List.of(typeBodyDdl)), null, boundValues));
+
+ ObjectSource source = agent.getObjectSource("APP", "T_ADDR", "TYPE_BODY");
+
+ Assertions.assertTrue(source.getSource().startsWith("CREATE OR REPLACE TYPE BODY"), source.getSource());
+ Assertions.assertTrue(source.getSource().contains("TYPE local_items IS TABLE OF NUMBER"), source.getSource());
+ Assertions.assertTrue(source.getSource().contains("CREATE TYPE demo AS OBJECT"), source.getSource());
+ Assertions.assertTrue(source.getSource().contains("q'!CREATE TYPE demo AS OBJECT"), source.getSource());
+ Assertions.assertFalse(source.isEditable());
+ String query = sqls.stream().filter(sql -> sql.contains("SYS.SYSTEXTS")).findFirst().orElseThrow();
+ Assertions.assertTrue(query.contains("a.OBJECT_ID = o.ID"), query);
+ Assertions.assertTrue(query.contains("a.OWNER = s.NAME AND a.OBJECT_NAME = o.NAME"), query);
+ Assertions.assertTrue(query.contains("a.OBJECT_TYPE = ?"), query);
+ Assertions.assertEquals(List.of("APP", "T_ADDR", "TYPE BODY"), boundValues);
+ }
+
@Test
void fallsBackToAllSourcePackageBodyDdlWhenDbmsMetadataPackageIsMissing() {
DamengAgent agent = new DamengAgent();
@@ -1596,7 +1698,7 @@ class DamengAgentMetadataTest {
ObjectSource source = agent.getObjectSource("APP", "T_ADDR", "TYPE");
Assertions.assertTrue(source.getSource().startsWith("CREATE OR REPLACE TYPE"), source.getSource());
- Assertions.assertTrue(source.isEditable());
+ Assertions.assertFalse(source.isEditable());
}
@Test
@@ -1647,6 +1749,26 @@ class DamengAgentMetadataTest {
Assertions.assertTrue(sqls.stream().anyMatch(sql -> sql.contains("SYS.SYSTEXTS")), String.join("\n", sqls));
}
+ @Test
+ void typeGetterRejectsUnavailablePlaceholderWhenCatalogSourcesAreEmptyOrUnavailable() {
+ for (String type : List.of("TYPE", "TYPE_BODY")) {
+ DamengAgent emptyAgent = new DamengAgent();
+ List<String> emptySqls = new ArrayList<>();
+ TestSupport.setPrivateConnection(emptyAgent, catalogFallbackConnection(
+ missingDbmsMetadataPackageError(), emptySqls, List.of(), null, List.of(), null));
+ Assertions.assertThrows(RuntimeException.class, () -> emptyAgent.getObjectSource("APP", "T_NO_SOURCE", type));
+
+ DamengAgent unavailableAgent = new DamengAgent();
+ List<String> unavailableSqls = new ArrayList<>();
+ TestSupport.setPrivateConnection(unavailableAgent, catalogFallbackConnection(
+ missingDbmsMetadataPackageError(), unavailableSqls, List.of(),
+ missingCatalogViewError("ALL_SOURCE"), List.of(), missingCatalogViewError("SYS.SYSTEXTS")));
+ Assertions.assertThrows(RuntimeException.class, () -> unavailableAgent.getObjectSource("APP", "T_NO_SOURCE", type));
+ Assertions.assertTrue(unavailableSqls.stream().anyMatch(sql -> sql.contains("FROM ALL_SOURCE")), String.join("\n", unavailableSqls));
+ Assertions.assertTrue(unavailableSqls.stream().anyMatch(sql -> sql.contains("SYS.SYSTEXTS")), String.join("\n", unavailableSqls));
+ }
+ }
+
@Test
void propagatesConnectionResetWithoutCatalogFallback() {
DamengAgent agent = new DamengAgent();
@@ -2930,6 +3052,35 @@ class DamengAgentMetadataTest {
});
}
+ private static Connection getDdlResultWithCatalogConnection(
+ List<String> sqls,
+ String getDdlSource,
+ List<List<Object>> allSourceRows
+ ) {
+ return proxy(Connection.class, (method, args) -> {
+ if ("prepareStatement".equals(method.getName())) {
+ String sql = (String) args[0];
+ sqls.add(sql);
+ if (sql.contains("DBMS_METADATA.GET_DDL")) {
+ return metadataStatement(List.of(Arrays.asList((Object) getDdlSource)));
+ }
+ if (sql.contains("FROM ALL_SOURCE")) {
+ return metadataStatement(allSourceRows);
+ }
+ if (sql.contains("SYS.SYSTEXTS")) {
+ return metadataStatement(List.of());
+ }
+ }
+ if ("close".equals(method.getName())) {
+ return null;
+ }
+ if ("isClosed".equals(method.getName())) {
+ return false;
+ }
+ return defaultValue(method.getReturnType());
+ });
+ }
+
/** 模拟 DM 实例未安装 DBMS_METADATA 系统包时的典型错误([‑2207]/[‑3325])。 */
private static SQLException missingDbmsMetadataPackageError() {
return new SQLException(
@@ -2956,6 +3107,19 @@ class DamengAgentMetadataTest {
SQLException allSourceError,
List<List<Object>> systemTextRows,
SQLException systemTextError
+ ) {
+ return catalogFallbackConnection(
+ dbmsMetadataError, sqls, allSourceRows, allSourceError, systemTextRows, systemTextError, null);
+ }
+
+ private static Connection catalogFallbackConnection(
+ SQLException dbmsMetadataError,
+ List<String> sqls,
+ List<List<Object>> allSourceRows,
+ SQLException allSourceError,
+ List<List<Object>> systemTextRows,
+ SQLException systemTextError,
+ List<String> boundSystemTextValues
) {
return proxy(Connection.class, (method, args) -> {
String name = method.getName();
@@ -2980,7 +3144,22 @@ class DamengAgentMetadataTest {
if (systemTextError != null) {
return failingMetadataStatement(systemTextError);
}
- return metadataStatement(systemTextRows);
+ if (boundSystemTextValues == null) {
+ return metadataStatement(systemTextRows);
+ }
+ return proxy(PreparedStatement.class, (statementMethod, statementArgs) -> {
+ if ("setString".equals(statementMethod.getName())) {
+ boundSystemTextValues.add((String) statementArgs[1]);
+ return null;
+ }
+ if ("executeQuery".equals(statementMethod.getName())) {
+ return metadataResultSet(systemTextRows);
+ }
+ if ("close".equals(statementMethod.getName())) {
+ return null;
+ }
+ return defaultValue(statementMethod.getReturnType());
+ });
}
if (sql.contains("FROM ALL_VIEWS")) {
return metadataStatement(List.of(List.of("SELECT 1 AS ID FROM DUAL")));
diff --git a/agents/drivers/dameng/src/test/java/com/dbx/agent/dameng/DamengAgentTest.java b/agents/drivers/dameng/src/test/java/com/dbx/agent/dameng/DamengAgentTest.java
index f728642f46..c908d83b64 100644
--- a/agents/drivers/dameng/src/test/java/com/dbx/agent/dameng/DamengAgentTest.java
+++ b/agents/drivers/dameng/src/test/java/com/dbx/agent/dameng/DamengAgentTest.java
@@ -489,6 +489,19 @@ class DamengAgentTest extends JdbcFakeExecutionBehaviorTest {
assertEquals(List.of("APP", "SEQUENCE", "PACKAGE", "PACKAGE BODY", 20), query.args());
}
+ @Test
+ void constrainedObjectQueriesIncludeTypesAndBodies() {
+ DamengAgent.MetadataQuery query = DamengAgent.buildConstrainedObjectsQuery(
+ "APP", new MetadataListConstraints(null, 20, null, List.of("TYPE", "TYPE_BODY")));
+ assertTrue(query.sql().contains("o.OBJECT_TYPE IN (?, ?)"));
+ assertEquals(List.of("APP", "TYPE", "TYPE BODY", 20), query.args());
+
+ DamengAgent.MetadataQuery raw = DamengAgent.buildRawConstrainedObjectsQuery(
+ "APP", new MetadataListConstraints(null, null, null, List.of("TYPE", "TYPE_BODY")));
+ assertTrue(raw.sql().contains("o.OBJECT_TYPE IN (?, ?)"));
+ assertEquals(List.of("APP", "TYPE", "TYPE BODY"), raw.args());
+ }
+
@Test
void rawObjectQueryIncludesDamengPackageBodyCatalogType() {
DamengAgent.MetadataQuery query = DamengAgent.buildRawConstrainedObjectsQuery(
diff --git a/agents/drivers/oceanbase-oracle/src/main/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgent.java b/agents/drivers/oceanbase-oracle/src/main/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgent.java
index 6a4b182148..07d04757ac 100644
--- a/agents/drivers/oceanbase-oracle/src/main/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgent.java
+++ b/agents/drivers/oceanbase-oracle/src/main/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgent.java
@@ -1375,6 +1375,12 @@ public final class OceanBaseOracleAgent extends ConfiguredJdbcAgent {
throw metadataError;
}
}
+ if ("TYPE".equals(objectType) || "TYPE_BODY".equals(objectType)) {
+ if (source == null || source.trim().isEmpty()) {
+ throw new SQLException("No complete source available for " + owner + "." + name + " (" + objectType + ")");
+ }
+ return new ObjectSource(name, objectType, owner, source, false);
+ }
return new ObjectSource(name, objectType, owner, source == null ? "" : source);
}
diff --git a/agents/drivers/oceanbase-oracle/src/test/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleObjectListTest.java b/agents/drivers/oceanbase-oracle/src/test/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleObjectListTest.java
index b4c0463dac..5b59ea9b61 100644
--- a/agents/drivers/oceanbase-oracle/src/test/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleObjectListTest.java
+++ b/agents/drivers/oceanbase-oracle/src/test/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleObjectListTest.java
@@ -177,6 +177,29 @@ class OceanBaseOracleObjectListTest {
call.assertClosed();
}
+ @Test
+ void typeBodySourcePreservesQuotedIdentityAndIsReadOnly() {
+ JdbcFixture jdbc = new JdbcFixture();
+ JdbcCall call = jdbc.rows(row("TYPE BODY \"Mixed Type\" AS\n"), row("END;\n"));
+
+ ObjectSource source = jdbc.agent.getObjectSource("Mixed.Owner", "Mixed Type", "TYPE_BODY");
+
+ assertEquals("CREATE OR REPLACE TYPE BODY \"Mixed Type\" AS\nEND;", source.getSource());
+ assertEquals("TYPE_BODY", source.getObject_type());
+ assertFalse(source.isEditable());
+ assertEquals(List.of("Mixed.Owner", "Mixed Type", "TYPE BODY"), call.args);
+ call.assertClosed();
+ }
+
+ @Test
+ void missingTypeSourceFailsInsteadOfReturningAnEmptyEditor() {
+ JdbcFixture jdbc = new JdbcFixture();
+ jdbc.rows();
+ jdbc.rows();
+
+ assertThrows(RuntimeException.class, () -> jdbc.agent.getObjectSource("APP", "MISSING_T", "TYPE"));
+ }
+
@Test
void filteredPagesKeepSameNameSpecAndBodyAndDoNotApplyOffsetTwice() {
JdbcFixture jdbc = new JdbcFixture();
diff --git a/agents/drivers/oracle-go/main.go b/agents/drivers/oracle-go/main.go
index 1992f611db..c5f3a8295f 100644
--- a/agents/drivers/oracle-go/main.go
+++ b/agents/drivers/oracle-go/main.go
@@ -216,6 +216,7 @@ UNION ALL
SELECT o.OBJECT_NAME,
CASE o.OBJECT_TYPE
WHEN 'PACKAGE BODY' THEN 'PACKAGE_BODY'
+ WHEN 'TYPE BODY' THEN 'TYPE_BODY'
WHEN 'MATERIALIZED VIEW' THEN 'MATERIALIZED_VIEW'
ELSE o.OBJECT_TYPE
END AS OBJECT_TYPE,
@@ -224,7 +225,7 @@ SELECT o.OBJECT_NAME,
i.TABLE_NAME AS PARENT_NAME
FROM USER_OBJECTS o
LEFT JOIN USER_INDEXES i ON o.OBJECT_TYPE = 'INDEX' AND i.INDEX_NAME = o.OBJECT_NAME
-WHERE o.OBJECT_TYPE IN ('VIEW', 'MATERIALIZED VIEW', 'PROCEDURE', 'FUNCTION', 'SEQUENCE', 'PACKAGE', 'PACKAGE BODY', 'INDEX')
+WHERE o.OBJECT_TYPE IN ('VIEW', 'MATERIALIZED VIEW', 'PROCEDURE', 'FUNCTION', 'SEQUENCE', 'PACKAGE', 'PACKAGE BODY', 'INDEX', 'TYPE', 'TYPE BODY')
UNION ALL
SELECT s.SYNONYM_NAME AS OBJECT_NAME,
'SYNONYM' AS OBJECT_TYPE,
@@ -242,9 +243,10 @@ const oracleListObjectsOrderSQL = `ORDER BY CASE OBJECT_TYPE
WHEN 'SEQUENCE' THEN 5
WHEN 'SYNONYM' THEN 6
WHEN 'PACKAGE' THEN 7
- ELSE 8
-END, OBJECT_NAME`
-const oracleListObjectsSQL = oracleListObjectsBaseSQL + "\n" + oracleListObjectsOrderSQL
+ WHEN 'TYPE' THEN 8
+ WHEN 'TYPE_BODY' THEN 9
+ ELSE 10
+END, OBJECT_NAME, OBJECT_TYPE`
const oracleListTriggersSQL = `
SELECT t.TRIGGER_NAME,
t.TRIGGERING_EVENT,
@@ -1891,12 +1893,25 @@ func oracleListSessionUserTablesQuery(constraints metadataListConstraints) oracl
}
func oracleListObjectsQuery(schema string, constraints metadataListConstraints) oracleMetadataListQuery {
+ return oracleListObjectsQueryWithTypeOwner(schema, schema, constraints)
+}
+
+func oracleListObjectsQueryWithTypeOwner(schema, typeOwner string, constraints metadataListConstraints) oracleMetadataListQuery {
+ baseSQL := oracleListObjectsBaseSQL + `
+UNION ALL
+SELECT o.OBJECT_NAME,
+ CASE o.OBJECT_TYPE WHEN 'TYPE BODY' THEN 'TYPE_BODY' ELSE o.OBJECT_TYPE END AS OBJECT_TYPE,
+ CAST(NULL AS VARCHAR2(4000)) AS COMMENTS,
+ CAST(NULL AS VARCHAR2(128)) AS PARENT_SCHEMA,
+ CAST(NULL AS VARCHAR2(128)) AS PARENT_NAME
+FROM ALL_OBJECTS o
+WHERE o.OWNER = :4 AND o.OBJECT_TYPE IN ('TYPE', 'TYPE BODY')`
return oracleConstrainedMetadataListQuery(
- oracleListObjectsBaseSQL,
+ baseSQL,
"OBJECT_NAME, OBJECT_TYPE, COMMENTS, PARENT_SCHEMA, PARENT_NAME",
"OBJECT_TYPE",
oracleListObjectsOrderSQL,
- []any{schema, schema, schema},
+ []any{schema, schema, schema, typeOwner},
constraints,
)
}
@@ -2025,12 +2040,17 @@ func (s *server) listTables(schema string, constraints metadataListConstraints)
}
func (s *server) listObjects(schema string, constraints metadataListConstraints) ([]objectInfo, error) {
+ rawTypeOwner := schema
schema, err := s.metadataSchema(schema, constraints.ExactIdentity)
if err != nil {
return nil, err
}
- query := oracleListObjectsQuery(schema, constraints)
- if s.metadataSchemaIsSessionUser(schema, constraints.ExactIdentity) {
+ if rawTypeOwner == "" {
+ rawTypeOwner = schema
+ }
+ query := oracleListObjectsQueryWithTypeOwner(schema, rawTypeOwner, constraints)
+ useSessionUser := rawTypeOwner == schema && s.metadataSchemaIsSessionUser(schema, constraints.ExactIdentity)
+ if useSessionUser {
query = oracleListSessionUserObjectsQuery(constraints)
}
rows, err := s.queryRows(query.SQL, query.Args)
@@ -2044,10 +2064,13 @@ func (s *server) listObjects(schema string, constraints metadataListConstraints)
var result []objectInfo
for rows.Next() {
var item objectInfo
- item.Schema = schema
if err := rows.Scan(&item.Name, &item.ObjectType, &item.Comment, &item.ParentSchema, &item.ParentName); err != nil {
return nil, err
}
+ item.Schema = schema
+ if strings.EqualFold(item.ObjectType, "TYPE") || strings.EqualFold(item.ObjectType, "TYPE_BODY") {
+ item.Schema = rawTypeOwner
+ }
result = append(result, item)
}
return emptyIfNil(result), rows.Err()
@@ -3362,12 +3385,52 @@ func oracleTriggerBody(source, description string) (string, bool) {
}
func (s *server) getObjectSource(schema, name, objectType string) (map[string]any, error) {
+ upperType := strings.ToUpper(objectType)
+ if upperType == "TYPE" || upperType == "TYPE_BODY" || upperType == "TYPE BODY" {
+ if schema == "" {
+ var err error
+ schema, err = s.normalizeSchemaForIdentity(schema)
+ if err != nil {
+ return nil, err
+ }
+ }
+ if upperType != "TYPE" {
+ upperType = "TYPE BODY"
+ }
+ source, found, sourceErr := s.loadObjectSourceText(schema, name, upperType)
+ if sourceErr != nil || !found || strings.TrimSpace(source) == "" {
+ db, dbErr := s.requireDB()
+ if dbErr != nil {
+ if sourceErr != nil {
+ return nil, errors.Join(sourceErr, dbErr)
+ }
+ return nil, dbErr
+ }
+ ddlType := "TYPE"
+ if upperType == "TYPE BODY" {
+ ddlType = "TYPE_BODY"
+ }
+ var ddl sql.NullString
+ ddlErr := db.QueryRow("SELECT DBMS_METADATA.GET_DDL(:1, :2, :3) FROM DUAL", ddlType, name, schema).Scan(&ddl)
+ if ddlErr == nil && ddl.Valid && strings.TrimSpace(ddl.String) != "" {
+ source = ddl.String
+ } else {
+ if ddlErr == nil {
+ ddlErr = fmt.Errorf("empty source returned")
+ }
+ if sourceErr != nil {
+ return nil, errors.Join(sourceErr, ddlErr)
+ }
+ return nil, ddlErr
+ }
+ }
+ return map[string]any{"name": name, "object_type": objectType, "schema": schema, "source": source, "editable": false}, nil
+ }
var err error
schema, err = s.normalizeSchemaForIdentity(schema)
if err != nil {
return nil, err
}
- upperType := strings.ToUpper(objectType)
if upperType == "VIEW" {
source, err := s.getViewSource(schema, name)
if err != nil {
diff --git a/agents/drivers/oracle-go/main_test.go b/agents/drivers/oracle-go/main_test.go
index d2b7742462..4b9b48ef90 100644
--- a/agents/drivers/oracle-go/main_test.go
+++ b/agents/drivers/oracle-go/main_test.go
@@ -2347,25 +2347,32 @@ func TestListSessionUserTablesQueryUsesUserDictionary(t *testing.T) {
}
func TestListObjectsSQLUsesSplitDictionaryQuery(t *testing.T) {
- sqlText := strings.ToUpper(oracleListObjectsSQL)
+ query := oracleListObjectsQuery("APP", metadataListConstraints{})
+ sqlText := strings.ToUpper(query.SQL)
if !strings.Contains(sqlText, "ALL_TABLES") || !strings.Contains(sqlText, "ALL_OBJECTS") {
- t.Fatalf("object listing should split tables from other objects, got: %s", oracleListObjectsSQL)
+ t.Fatalf("object listing should split tables from other objects, got: %s", query.SQL)
}
if !strings.Contains(sqlText, "UNION ALL") {
- t.Fatalf("object listing should union object metadata, got: %s", oracleListObjectsSQL)
+ t.Fatalf("object listing should union object metadata, got: %s", query.SQL)
}
if strings.Contains(sqlText, "ALL_TAB_COMMENTS") {
- t.Fatalf("object listing should not load comments during refresh, got: %s", oracleListObjectsSQL)
+ t.Fatalf("object listing should not load comments during refresh, got: %s", query.SQL)
}
if !strings.Contains(sqlText, "'PACKAGE BODY'") || !strings.Contains(sqlText, "PACKAGE_BODY") {
- t.Fatalf("object listing should include package bodies with normalized type, got: %s", oracleListObjectsSQL)
+ t.Fatalf("object listing should include package bodies with normalized type, got: %s", query.SQL)
}
if !strings.Contains(sqlText, "'SEQUENCE'") {
- t.Fatalf("object listing should include sequences, got: %s", oracleListObjectsSQL)
+ t.Fatalf("object listing should include sequences, got: %s", query.SQL)
+ }
+ if !strings.Contains(sqlText, "'TYPE BODY'") || !strings.Contains(sqlText, "TYPE_BODY") || !strings.Contains(sqlText, "'TYPE'") {
+ t.Fatalf("object listing should include TYPE and normalize TYPE BODY, got: %s", query.SQL)
+ }
+ if !strings.Contains(sqlText, "END, OBJECT_NAME, OBJECT_TYPE") {
+ t.Fatalf("same-name TYPE and TYPE BODY need deterministic ordering, got: %s", query.SQL)
}
if !strings.Contains(sqlText, "ALL_SYNONYMS") || !strings.Contains(sqlText, "'SYNONYM' AS OBJECT_TYPE") {
- t.Fatalf("object listing should include schema synonyms, got: %s", oracleListObjectsSQL)
+ t.Fatalf("object listing should include schema synonyms, got: %s", query.SQL)
}
}
@@ -2413,7 +2420,7 @@ func TestExactSchemaIndexAllDictionaryPagePreservesMissingParent(t *testing.T) {
owner := " Index Owner "
db, scripted := openOracleViewSourceTestDB(t, []oracleViewSourceQueryStep{
{queryContains: "SYS_CONTEXT('USERENV', 'SESSION_USER')", args: []driver.Value{}, rows: [][]driver.Value{{"Other Owner"}}},
- {queryContains: "ALL_INDEXES", args: []driver.Value{owner, owner, owner, "INDEX", int64(3), int64(1)}, columns: []string{"OBJECT_NAME", "OBJECT_TYPE", "COMMENTS", "PARENT_SCHEMA", "PARENT_NAME"}, rows: [][]driver.Value{{" Ix (a) ", "INDEX", nil, nil, nil}}},
+ {queryContains: "ALL_INDEXES", args: []driver.Value{owner, owner, owner, owner, "INDEX", int64(3), int64(1)}, columns: []string{"OBJECT_NAME", "OBJECT_TYPE", "COMMENTS", "PARENT_SCHEMA", "PARENT_NAME"}, rows: [][]driver.Value{{" Ix (a) ", "INDEX", nil, nil, nil}}},
})
s := newServer()
s.db = db
@@ -2457,11 +2464,114 @@ func TestExactTableDDLDoesNotBuildAnotherTargetAfterMetadataFailure(t *testing.T
func TestListSessionUserObjectsSQLIncludesSequences(t *testing.T) {
sqlText := strings.ToUpper(oracleListObjectsSessionUserBaseSQL)
- if !strings.Contains(sqlText, "FROM USER_OBJECTS") || !strings.Contains(sqlText, "'SEQUENCE'") {
+ if !strings.Contains(sqlText, "FROM USER_OBJECTS") || !strings.Contains(sqlText, "'SEQUENCE'") || !strings.Contains(sqlText, "'TYPE BODY'") || !strings.Contains(sqlText, "'TYPE'") {
t.Fatalf("session-user object listing should include sequences, got: %s", oracleListObjectsSessionUserBaseSQL)
}
}
+func TestGetOracleTypeSourceUsesExactIdentityAndCollectionDDLFallback(t *testing.T) {
+ const ddl = `CREATE TYPE "App"."MixedType" AS TABLE OF VARCHAR2(20)`
+ db, scripted := openOracleViewSourceTestDB(t, []oracleViewSourceQueryStep{
+ {queryContains: "DBMS_XMLGEN.CONVERT", args: []driver.Value{"App", "MixedType", "TYPE"}, rows: [][]driver.Value{{nil}}},
+ {queryContains: "DBMS_METADATA.GET_DDL(:1, :2, :3)", args: []driver.Value{"TYPE", "MixedType", "App"}, rows: [][]driver.Value{{ddl}}},
+ })
+ s := newServer()
+ s.db = db
+ result, err := s.getObjectSource("App", "MixedType", "TYPE")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if result["source"] != ddl || result["editable"] != false || result["name"] != "MixedType" {
+ t.Fatalf("unexpected type source: %#v", result)
+ }
+ if scripted.next != len(scripted.steps) {
+ t.Fatalf("expected %d queries, got %d", len(scripted.steps), scripted.next)
+ }
+}
+
+func TestGetOracleTypeBodyReadsLongQuotedNameAsTypeBodyReadonly(t *testing.T) {
+ const name = "Mixed Type"
+ source := "TYPE BODY \"Mixed Type\" AS\n" + strings.Repeat(" MEMBER PROCEDURE P IS BEGIN NULL; END;\n", 1200) + "END;"
+ db, scripted := openOracleViewSourceTestDB(t, []oracleViewSourceQueryStep{
+ {queryContains: "DBMS_XMLGEN.CONVERT", args: []driver.Value{"App", name, "TYPE BODY"}, rows: [][]driver.Value{{source}}},
+ })
+ s := newServer()
+ s.db = db
+ result, err := s.getObjectSource("App", name, "TYPE_BODY")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if result["source"] != source || result["editable"] != false || result["object_type"] != "TYPE_BODY" {
+ t.Fatalf("unexpected body source: %#v", result)
+ }
+ if scripted.next != len(scripted.steps) {
+ t.Fatalf("expected exact identity query only; got %d queries", scripted.next)
+ }
+}
+
+func TestGetOracleTypeRejectsEmptySourceWhenMetadataFallbackFails(t *testing.T) {
+ db, scripted := openOracleViewSourceTestDB(t, []oracleViewSourceQueryStep{
+ {queryContains: "DBMS_XMLGEN.CONVERT", args: []driver.Value{"APP", "EMPTY_T", "TYPE"}, rows: [][]driver.Value{{nil}}},
+ {queryContains: "DBMS_METADATA.GET_DDL(:1, :2, :3)", args: []driver.Value{"TYPE", "EMPTY_T", "APP"}, err: errors.New("metadata unavailable")},
+ })
+ s := newServer()
+ s.db = db
+ result, err := s.getObjectSource("APP", "EMPTY_T", "TYPE")
+ if err == nil || result != nil {
+ t.Fatalf("expected empty/missing type source to fail, got result=%#v err=%v", result, err)
+ }
+ if scripted.next != len(scripted.steps) {
+ t.Fatalf("expected %d queries, got %d", len(scripted.steps), scripted.next)
+ }
+}
+
+func TestGetOracleTypeBodyFallsBackAfterDictionaryErrorsWithExactPaddedIdentity(t *testing.T) {
+ const owner = " Mixed Owner "
+ const name = " Mixed Body "
+ const sourceErr = "dictionary denied"
+ const ddl = `CREATE TYPE BODY " Mixed Owner " . " Mixed Body " AS END;`
+ db, scripted := openOracleViewSourceTestDB(t, []oracleViewSourceQueryStep{
+ {queryContains: "DBMS_XMLGEN.CONVERT", args: []driver.Value{owner, name, "TYPE BODY"}, err: errors.New(sourceErr)},
+ {queryContains: "SELECT TEXT", args: []driver.Value{owner, name, "TYPE BODY"}, err: errors.New("line view denied")},
+ {queryContains: "DBMS_METADATA.GET_DDL(:1, :2, :3)", args: []driver.Value{"TYPE_BODY", name, owner}, rows: [][]driver.Value{{ddl}}},
+ })
+ s := newServer()
+ s.db = db
+ result, err := s.getObjectSource(owner, name, "TYPE_BODY")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if result["schema"] != owner || result["name"] != name || result["source"] != ddl || result["editable"] != false {
+ t.Fatalf("type-body identity/source changed: %#v", result)
+ }
+ if scripted.next != len(scripted.steps) {
+ t.Fatalf("expected %d queries, got %d", len(scripted.steps), scripted.next)
+ }
+}
+
+func TestGetOracleTypeFallsBackAfterDictionaryErrorsWithExactPaddedIdentity(t *testing.T) {
+ const owner = " Mixed Owner "
+ const name = " Mixed Type "
+ const ddl = `CREATE TYPE " Mixed Owner " . " Mixed Type " AS OBJECT ( VALUE NUMBER )`
+ db, scripted := openOracleViewSourceTestDB(t, []oracleViewSourceQueryStep{
+ {queryContains: "DBMS_XMLGEN.CONVERT", args: []driver.Value{owner, name, "TYPE"}, err: errors.New("ALL_SOURCE denied")},
+ {queryContains: "SELECT TEXT", args: []driver.Value{owner, name, "TYPE"}, err: errors.New("ALL_SOURCE lines denied")},
+ {queryContains: "DBMS_METADATA.GET_DDL(:1, :2, :3)", args: []driver.Value{"TYPE", name, owner}, rows: [][]driver.Value{{ddl}}},
+ })
+ s := newServer()
+ s.db = db
+ result, err := s.getObjectSource(owner, name, "TYPE")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if result["schema"] != owner || result["name"] != name || result["source"] != ddl || result["editable"] != false {
+ t.Fatalf("type identity/source changed: %#v", result)
+ }
+ if scripted.next != len(scripted.steps) {
+ t.Fatalf("expected %d queries, got %d", len(scripted.steps), scripted.next)
+ }
+}
+
func TestListObjectsQueryAppliesMetadataConstraints(t *testing.T) {
query := oracleListObjectsQuery("APP", metadataListConstraints{
Filter: "pkg%",
@@ -2470,19 +2580,19 @@ func TestListObjectsQueryAppliesMetadataConstraints(t *testing.T) {
})
sqlText := strings.ToUpper(query.SQL)
- if !strings.Contains(sqlText, "UPPER(OBJECT_NAME) LIKE :4 ESCAPE '\\'") {
+ if !strings.Contains(sqlText, "UPPER(OBJECT_NAME) LIKE :5 ESCAPE '\\'") {
t.Fatalf("object listing should push filter predicate, got: %s", query.SQL)
}
- if !strings.Contains(sqlText, "OBJECT_TYPE IN (:5,:6)") {
+ if !strings.Contains(sqlText, "OBJECT_TYPE IN (:6,:7)") {
t.Fatalf("object listing should push object type predicate, got: %s", query.SQL)
}
- if !strings.Contains(sqlText, "ROWNUM <= :7") || !strings.Contains(sqlText, "DBX_RN > :8") {
+ if !strings.Contains(sqlText, "ROWNUM <= :8") || !strings.Contains(sqlText, "DBX_RN > :9") {
t.Fatalf("object listing should use rownum pagination, got: %s", query.SQL)
}
- if len(query.Args) != 8 {
+ if len(query.Args) != 9 {
t.Fatalf("unexpected args: %#v", query.Args)
}
- if query.Args[0] != "APP" || query.Args[1] != "APP" || query.Args[2] != "APP" || query.Args[3] != "%P%K%G%\\%%" || query.Args[4] != "FUNCTION" || query.Args[5] != "PACKAGE" || query.Args[6] != 25 || query.Args[7] != 0 {
+ if query.Args[0] != "APP" || query.Args[1] != "APP" || query.Args[2] != "APP" || query.Args[3] != "APP" || query.Args[4] != "%P%K%G%\\%%" || query.Args[5] != "FUNCTION" || query.Args[6] != "PACKAGE" || query.Args[7] != 25 || query.Args[8] != 0 {
t.Fatalf("object constraints args were not normalized: %#v", query.Args)
}
}
@@ -2536,14 +2646,44 @@ func TestListObjectsQuerySupportsSynonymOnlyFiltering(t *testing.T) {
if !strings.Contains(sqlText, "FROM ALL_SYNONYMS") || !strings.Contains(sqlText, "S.OWNER = :3") {
t.Fatalf("cross-schema synonym listing should use the selected owner, got: %s", query.SQL)
}
- if !strings.Contains(sqlText, "OBJECT_TYPE IN (:5)") {
+ if !strings.Contains(sqlText, "OBJECT_TYPE IN (:6)") {
t.Fatalf("synonym filtering should be pushed into the constrained query, got: %s", query.SQL)
}
- if len(query.Args) != 7 || query.Args[2] != "AP" || query.Args[3] != "%S%P%E%C%" || query.Args[4] != "SYNONYM" || query.Args[5] != 30 || query.Args[6] != 20 {
+ if len(query.Args) != 8 || query.Args[2] != "AP" || query.Args[3] != "AP" || query.Args[4] != "%S%P%E%C%" || query.Args[5] != "SYNONYM" || query.Args[6] != 30 || query.Args[7] != 20 {
t.Fatalf("unexpected synonym query args: %#v", query.Args)
}
}
+func TestListObjectsPagesSameNameTypeAndBodyUnderExactQuotedOwner(t *testing.T) {
+ const owner = " Mixed Owner "
+ steps := []oracleViewSourceQueryStep{
+ {queryContains: "END, OBJECT_NAME, OBJECT_TYPE", columns: []string{"OBJECT_NAME", "OBJECT_TYPE", "COMMENTS", "PARENT_SCHEMA", "PARENT_NAME"}, args: []driver.Value{"MIXED OWNER", "MIXED OWNER", "MIXED OWNER", owner, "%T%Y%P%E%", "TYPE", "TYPE_BODY", int64(1), int64(0)}, rows: [][]driver.Value{{"Mixed Type", "TYPE", nil, nil, nil}}},
+ {queryContains: "END, OBJECT_NAME, OBJECT_TYPE", columns: []string{"OBJECT_NAME", "OBJECT_TYPE", "COMMENTS", "PARENT_SCHEMA", "PARENT_NAME"}, args: []driver.Value{"MIXED OWNER", "MIXED OWNER", "MIXED OWNER", owner, "%T%Y%P%E%", "TYPE", "TYPE_BODY", int64(2), int64(1)}, rows: [][]driver.Value{{"Mixed Type", "TYPE_BODY", nil, nil, nil}}},
+ }
+ db, scripted := openOracleViewSourceTestDB(t, steps)
+ s := newServer()
+ s.db = db
+ constraints := metadataListConstraints{Filter: "type", Limit: 1, ObjectTypes: []string{"TYPE", "TYPE_BODY"}}
+ specs, err := s.listObjects(owner, constraints)
+ if err != nil {
+ t.Fatal(err)
+ }
+ constraints.Offset = 1
+ bodies, err := s.listObjects(owner, constraints)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(specs) != 1 || len(bodies) != 1 || specs[0].Name != bodies[0].Name || specs[0].ObjectType != "TYPE" || bodies[0].ObjectType != "TYPE_BODY" {
+ t.Fatalf("same-name TYPE/BODY page identities lost: specs=%#v bodies=%#v", specs, bodies)
+ }
+ if specs[0].Schema != owner || bodies[0].Schema != owner {
+ t.Fatalf("exact quoted owner not retained: %#v %#v", specs[0], bodies[0])
+ }
+ if scripted.next != len(scripted.steps) {
+ t.Fatalf("expected %d list queries, got %d", len(scripted.steps), scripted.next)
+ }
+}
+
func TestOracleListTriggersSQLLoadsSourceWithoutLongColumns(t *testing.T) {
sqlText := strings.ToUpper(oracleListTriggersSQL)
@@ -3748,7 +3888,7 @@ func (c *oracleViewSourceConn) QueryContext(
values[index] = arg.Value
}
if !reflect.DeepEqual(values, step.args) {
- return nil, fmt.Errorf("unexpected query arguments: got %v, want %v (query %q)", values, step.args, query)
+ return nil, fmt.Errorf("unexpected query arguments: got %#v, want %#v (query %q)", values, step.args, query)
}
if step.err != nil {
return nil, step.err
diff --git a/apps/desktop/src/App.vue b/apps/desktop/src/App.vue
index 1ad13d2e58..622b556d4c 100644
--- a/apps/desktop/src/App.vue
+++ b/apps/desktop/src/App.vue
@@ -102,6 +102,8 @@ import {
} from "@/lib/sql/sqlNavigation";
import { isObjectDependencySection, type ObjectDependencyTarget } from "@/lib/database/objectDependencyDetails";
import { buildEditableObjectSource } from "@/lib/table/objectSourceEditor";
+import { isOracleFamilyTypeSource } from "@/lib/database/databaseObjectCapabilities";
+import { oracleTypeManagementRequest } from "@/lib/table/oracleTypeManagementRequest";
import { saveObjectSourceTab } from "@/lib/table/objectSourceTabSave";
import { loadEditableObjectSourceForEditor } from "@/lib/table/objectSourceLoad";
import { schemaAfterConnectionSwitch } from "@/lib/schema/connectionSchemaInitialization";
@@ -250,6 +252,7 @@ const QuickOpenDialog = defineAsyncComponent(() => import("@/components/quick-op
const TabSwitcherDialog = defineAsyncComponent(() => import("@/components/tabs/TabSwitcherDialog.vue"));
const QueryEditorDdlViewDialog = defineAsyncComponent(() => import("@/components/objects/DdlViewDialog.vue"));
const QueryEditorObjectSourceDialog = defineAsyncComponent(() => import("@/components/objects/ObjectSourceDialog.vue"));
+const OracleTypeManagementDialog = defineAsyncComponent(() => import("@/components/objects/OracleTypeManagementDialog.vue"));
type AiAssistantHandle = {
openPluginConversation: (request: AiPluginConversationRequest) => void;
@@ -4137,6 +4140,10 @@ async function handleQuickOpenSelect(item: any) {
const databaseType = effectiveDatabaseTypeForConnection(connectionStore.getConfig(item.connectionId));
if (!databaseType) throw new Error("Connection type is unavailable.");
const objectName = item.objectName || item.tableName;
+ if (isOracleFamilyTypeSource(databaseType, objectType)) {
+ queryStore.openObjectSourceTabPending({ connectionId: item.connectionId, database: item.database, schema, title: `Source - ${objectName}`, initialEditing: false, request: { name: objectName, objectType, signature: item.signature } });
+ return;
+ }
const { editableSource, objectType: resolvedType } = await loadEditableObjectSourceForEditor(api.getObjectSource, buildEditableObjectSource, {
connectionId: item.connectionId,
database: item.database,
@@ -5836,6 +5843,7 @@ onUnmounted(() => {
<CloseActionPromptDialog v-if="isDesktop && showCloseActionPrompt" :open="showCloseActionPrompt" @update:open="handleCloseActionPromptOpenChange" @quit="chooseQuit" @minimize="chooseMinimize" />
<AiRunsClosePromptDialog v-if="isDesktop && showAiRunsClosePrompt" v-model:open="showAiRunsClosePrompt" :count="blockingAiRunCount" @cancel="cancelPendingAppClose" @quit="confirmQuitWithActiveAiRuns" />
<QuickOpenDialog :open="showQuickOpen" :initial-content-mode="quickOpenForceContent" @update:open="showQuickOpen = $event" @select="handleQuickOpenSelect" />
+ <OracleTypeManagementDialog v-if="oracleTypeManagementRequest" />
<TabSwitcherDialog :open="showTabSwitcher" :tabs="tabSwitcherTabs" :selected-index="tabSwitcherIndex" :shortcut-hint="tabSwitcherShortcutHint" @update:open="handleTabSwitcherOpenChange" @update:selected-index="tabSwitcherIndex = $event" @select="handleTabSwitcherSelect" />
</div>
<Teleport to="body">
diff --git a/apps/desktop/src/components/connection/__tests__/ConnectionDialog.deepLinkEdit.spec.ts b/apps/desktop/src/components/connection/__tests__/ConnectionDialog.deepLinkEdit.spec.ts
index fc1559e4be..fd6f8ac4be 100644
--- a/apps/desktop/src/components/connection/__tests__/ConnectionDialog.deepLinkEdit.spec.ts
+++ b/apps/desktop/src/components/connection/__tests__/ConnectionDialog.deepLinkEdit.spec.ts
@@ -1,14 +1,15 @@
// @vitest-environment happy-dom
import { createApp, defineComponent, h, nextTick, reactive, type App } from "vue";
+import { createPinia, setActivePinia } from "pinia";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import i18n from "@/i18n";
import type { ConnectionConfig } from "@/types/database";
-import { parseConnectionDeepLinkUpdate } from "@/lib/connection/connectionDeepLink";
+import { parseConnectionDeepLink, parseConnectionDeepLinkUpdate } from "@/lib/connection/connectionDeepLink";
const visibleTab = vi.hoisted(() => ({ value: "connection" }));
-const { store, settings, backend } = vi.hoisted(() => ({
+const { store, settings, backend, actualStoreHolder } = vi.hoisted(() => ({
store: {
connectionGroupOptions: [],
newConnectionGroupId: null,
@@ -26,9 +27,11 @@ const { store, settings, backend } = vi.hoisted(() => ({
applyGlobalTimeouts: vi.fn((config) => config),
getConfig: vi.fn(),
},
+ actualStoreHolder: { value: null as unknown },
settings: {
- editorSettings: { sidebarShowConnectionNotes: false, globalConnectTimeoutSecs: 10, globalQueryTimeoutSecs: 0 },
+ editorSettings: { sidebarShowConnectionNotes: false, globalConnectTimeoutSecs: 10, globalQueryTimeoutSecs: 0, connectTimeoutInheritConnectionIds: [], queryTimeoutInheritConnectionIds: [] },
rememberedDatabaseForConnection: vi.fn(() => ""),
+ initEditorSettings: vi.fn().mockResolvedValue(undefined),
persistEditorSettings: vi.fn(),
updateEditorSettings: vi.fn(),
updateEditorSettingsAndPersist: vi.fn(),
@@ -36,6 +39,8 @@ const { store, settings, backend } = vi.hoisted(() => ({
backend: {
connectDb: vi.fn(),
disconnectDb: vi.fn(),
+ redisListDatabases: vi.fn(),
+ listSchemas: vi.fn(),
testConnectionWithInfo: vi.fn(),
listDatabases: vi.fn(),
listPlugins: vi.fn(),
@@ -43,12 +48,23 @@ const { store, settings, backend } = vi.hoisted(() => ({
listJdbcMavenBundles: vi.fn(),
listJdbcLocalBundles: vi.fn(),
listSshConfigHosts: vi.fn(),
+ listInstalledAgents: vi.fn(),
listInstalledAgentsLocal: vi.fn(),
listenAgentInstallProgress: vi.fn(),
+ loadConnections: vi.fn().mockResolvedValue([]),
+ saveConnections: vi.fn().mockResolvedValue(undefined),
+ loadEditorSettings: vi.fn().mockResolvedValue(null),
+ loadPinnedTreeNodeIds: vi.fn().mockResolvedValue([]),
+ loadTableVGroups: vi.fn().mockResolvedValue({}),
+ saveTableVGroups: vi.fn().mockResolvedValue(undefined),
+ loadSidebarLayout: vi.fn().mockResolvedValue({ groups: [], order: [] }),
+ saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
+ loadTunnelProfiles: vi.fn().mockResolvedValue([]),
+ saveEditorSettings: vi.fn().mockResolvedValue(undefined),
},
}));
-vi.mock("@/stores/connectionStore", () => ({ useConnectionStore: () => store, CONNECTION_ATTEMPT_CANCELLED_MESSAGE: "cancelled" }));
+vi.mock("@/stores/connectionStore", () => ({ useConnectionStore: () => actualStoreHolder.value ?? store, CONNECTION_ATTEMPT_CANCELLED_MESSAGE: "cancelled" }));
vi.mock("@/stores/settingsStore", async (original) => ({ ...(await original<typeof import("@/stores/settingsStore")>()), useSettingsStore: () => settings }));
vi.mock("@/stores/tunnelProfileStore", () => ({ useTunnelProfileStore: () => ({ profiles: [], profileById: () => undefined, init: vi.fn() }) }));
vi.mock("@/lib/backend/api", async (original) => ({ ...(await original<typeof import("@/lib/backend/api")>()), ...backend }));
@@ -193,8 +209,31 @@ async function mountDialog(config: ConnectionConfig, url: string, initiallyOpen
return props;
}
+async function mountNewDialog(url?: string) {
+ const props = reactive({ open: true, prefillConfig: url ? parseConnectionDeepLink(url) : null });
+ const container = document.createElement("div");
+ document.body.append(container);
+ const app = createApp(
+ defineComponent({
+ setup: () => () =>
+ h(ConnectionDialog, {
+ ...props,
+ "onUpdate:open": (value: boolean) => {
+ props.open = value;
+ },
+ }),
+ }),
+ );
+ app.use(i18n);
+ mountedApps.push(app);
+ app.mount(container);
+ await settle();
+ return props;
+}
+
beforeEach(() => {
vi.clearAllMocks();
+ actualStoreHolder.value = null;
visibleTab.value = "connection";
i18n.global.locale.value = "en";
for (const fn of Object.values(backend)) fn.mockResolvedValue([]);
@@ -206,6 +245,8 @@ beforeEach(() => {
afterEach(() => {
for (const app of mountedApps.splice(0)) app.unmount();
document.body.innerHTML = "";
+ (actualStoreHolder.value as { $dispose?: () => void } | null)?.$dispose?.();
+ actualStoreHolder.value = null;
});
describe("ConnectionDialog deep-link edit confirmation", () => {
@@ -352,6 +393,222 @@ describe("ConnectionDialog deep-link edit confirmation", () => {
expect(store.connect).not.toHaveBeenCalled();
});
+ it("preserves a protected generic JDBC target when only its name changes", async () => {
+ const saved = savedConnection({
+ db_type: "jdbc",
+ driver_profile: "jdbc",
+ driver_label: "JDBC",
+ host: "db.example.test",
+ port: 2881,
+ username: "saved-user",
+ password: "__DBX_SAVED_CREDENTIAL__:synthetic-password",
+ connection_string: "__DBX_SAVED_CREDENTIAL__:synthetic-url",
+ jdbc_driver_class: "example.Driver",
+ jdbc_driver_paths: ["driver.jar"],
+ jdbc_dialect: "oceanbase-oracle",
+ production_badge_scope: undefined,
+ });
+ await mountDialog(saved, "");
+ const name = [...document.querySelectorAll<HTMLInputElement>("input")].find((input) => input.value === saved.name);
+ expect(name).toBeTruthy();
+ name!.value = "Renamed JDBC";
+ name!.dispatchEvent(new Event("input", { bubbles: true }));
+ await settle();
+ const save = [...document.querySelectorAll("button")].find((button) => button.textContent?.trim() === "Save");
+ save!.click();
+ await settle();
+
+ expect(store.updateConnection).toHaveBeenCalledTimes(1);
+ const submitted = store.updateConnection.mock.calls[0][0];
+ expect(submitted.name).toBe("Renamed JDBC");
+ expect(submitted.production_badge_scope).toBeUndefined();
+ expect(submitted).toMatchObject({
+ db_type: saved.db_type,
+ driver_profile: saved.driver_profile,
+ host: saved.host,
+ port: saved.port,
+ username: saved.username,
+ password: saved.password,
+ connection_string: saved.connection_string,
+ jdbc_driver_class: saved.jdbc_driver_class,
+ jdbc_driver_paths: saved.jdbc_driver_paths,
+ });
+ });
+
+ it.each([true, false] as const)("preserves protected target settings through real Store load and Dialog save (%s DB links)", async (showDatabaseLinks) => {
+ setActivePinia(createPinia());
+ const saved = savedConnection({
+ id: "loaded-protected-jdbc",
+ db_type: "jdbc",
+ driver_profile: "jdbc",
+ driver_label: undefined,
+ host: "db.example.test",
+ port: 2881,
+ username: "saved-user",
+ password: "__DBX_SAVED_CREDENTIAL__:synthetic-password",
+ connection_string: "__DBX_SAVED_CREDENTIAL__:synthetic-url",
+ jdbc_driver_class: "example.Driver",
+ jdbc_driver_paths: ["driver.jar"],
+ url_params: undefined,
+ show_database_links: showDatabaseLinks,
+ production_badge_scope: undefined,
+ });
+ const untouched = savedConnection({
+ id: "untouched-protected-jdbc",
+ name: "Untouched JDBC",
+ db_type: "jdbc",
+ driver_profile: "jdbc",
+ driver_label: undefined,
+ host: "schema.example.test",
+ port: 2882,
+ username: "schema-user",
+ password: "__DBX_SAVED_CREDENTIAL__:synthetic-schema-password",
+ connection_string: "__DBX_SAVED_CREDENTIAL__:synthetic-schema-url",
+ jdbc_driver_class: "example.SchemaDriver",
+ jdbc_driver_paths: ["schema-driver.jar"],
+ url_params: undefined,
+ show_database_links: undefined,
+ });
+ vi.mocked(backend.loadConnections).mockResolvedValue([saved, untouched]);
+ vi.mocked(backend.loadSidebarLayout).mockResolvedValue({ groups: [], order: [] });
+ const { useConnectionStore } = await vi.importActual<typeof import("@/stores/connectionStore")>("@/stores/connectionStore");
+ const actualStore = useConnectionStore();
+ actualStoreHolder.value = actualStore;
+ await actualStore.initFromDisk();
+ const loaded = actualStore.getConfig(saved.id)!;
+ expect(loaded.production_badge_scope).toBeUndefined();
+ expect(loaded.driver_label).toBe("jdbc");
+ expect(loaded.url_params).toBe("");
+ expect(loaded.show_database_links).toBe(showDatabaseLinks);
+ expect(actualStore.getConfig(untouched.id)?.show_database_links).toBeUndefined();
+
+ await mountDialog(loaded, "");
+ const name = [...document.querySelectorAll<HTMLInputElement>("input")].find((input) => input.value === loaded.name);
+ expect(name).toBeTruthy();
+ name!.value = "Renamed JDBC";
+ name!.dispatchEvent(new Event("input", { bubbles: true }));
+ await settle();
+ const save = [...document.querySelectorAll("button")].find((button) => button.textContent?.trim() === "Save");
+ save!.click();
+ await settle();
+
+ expect(backend.saveConnections).toHaveBeenCalledOnce();
+ const persisted = vi.mocked(backend.saveConnections).mock.calls[0][0][0];
+ const persistedUntouched = vi.mocked(backend.saveConnections).mock.calls[0][0].find((config) => config.id === untouched.id)!;
+ expect(persisted.name).toBe("Renamed JDBC");
+ expect(persisted.production_badge_scope).toBeUndefined();
+ expect(persisted.host).toBe("db.example.test");
+ expect(persisted.port).toBe(2881);
+ expect(persisted.connection_string).toBe(saved.connection_string);
+ expect(persisted.password).toBe(saved.password);
+ expect(persisted.show_database_links).toBe(showDatabaseLinks);
+ expect(persistedUntouched).toMatchObject({
+ id: untouched.id,
+ db_type: untouched.db_type,
+ driver_profile: untouched.driver_profile,
+ host: untouched.host,
+ port: untouched.port,
+ username: untouched.username,
+ password: untouched.password,
+ connection_string: untouched.connection_string,
+ jdbc_driver_class: untouched.jdbc_driver_class,
+ jdbc_driver_paths: untouched.jdbc_driver_paths,
+ });
+ expect(persistedUntouched.show_database_links).toBeUndefined();
+ });
+
+ it("keeps an explicitly selected badge scope on an unchanged generic JDBC target", async () => {
+ visibleTab.value = "advanced";
+ const saved = savedConnection({
+ db_type: "jdbc",
+ driver_profile: "jdbc",
+ driver_label: "JDBC",
+ host: "db.example.test",
+ port: 2881,
+ connection_string: "__DBX_SAVED_CREDENTIAL__:synthetic-url",
+ jdbc_driver_class: "example.Driver",
+ jdbc_driver_paths: ["driver.jar"],
+ production_badge_scope: undefined,
+ });
+ await mountDialog(saved, "");
+ const trigger = document.querySelector<HTMLButtonElement>("#production-badge-scope");
+ expect(trigger?.textContent).toContain("Database / schema (default)");
+ trigger!.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
+ await settle();
+ const option = [...document.querySelectorAll<HTMLElement>('[role="option"]')].find((element) => element.textContent?.trim() === "Table / object");
+ expect(option).toBeTruthy();
+ option!.dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true }));
+ await settle();
+ const save = [...document.querySelectorAll("button")].find((button) => button.textContent?.trim() === "Save");
+ save!.click();
+ await settle();
+
+ expect(store.updateConnection).toHaveBeenCalledWith(expect.objectContaining({ production_badge_scope: "table", host: "db.example.test", port: 2881 }));
+ });
+
+ it("keeps the existing generic JDBC normalization when its URL is replaced", async () => {
+ const saved = savedConnection({
+ db_type: "jdbc",
+ driver_profile: "jdbc",
+ driver_label: "JDBC",
+ host: "db.example.test",
+ port: 2881,
+ connection_string: "__DBX_SAVED_CREDENTIAL__:synthetic-url",
+ jdbc_driver_class: "example.Driver",
+ jdbc_driver_paths: ["driver.jar"],
+ });
+ await mountDialog(saved, "");
+ const url = [...document.querySelectorAll<HTMLInputElement>("input")].find((input) => input.value === saved.connection_string);
+ expect(url).toBeTruthy();
+ url!.value = "jdbc:example://new.example.test:9999/db";
+ url!.dispatchEvent(new Event("input", { bubbles: true }));
+ await settle();
+ const save = [...document.querySelectorAll("button")].find((button) => button.textContent?.trim() === "Save");
+ save!.click();
+ await settle();
+
+ expect(store.updateConnection).toHaveBeenCalledWith(
+ expect.objectContaining({
+ connection_string: "jdbc:example://new.example.test:9999/db",
+ host: "",
+ port: 0,
+ }),
+ );
+ });
+
+ it("keeps the generic JDBC new-connection endpoint normalization", async () => {
+ await mountNewDialog();
+ const jdbcCategory = [...document.querySelectorAll<HTMLButtonElement>("button")].find((button) => button.textContent?.trim() === "JDBC connection");
+ expect(jdbcCategory).toBeTruthy();
+ jdbcCategory!.click();
+ await settle();
+ const jdbcOption = document.querySelector<HTMLButtonElement>('[title="JDBC"]');
+ expect(jdbcOption).toBeTruthy();
+ jdbcOption!.click();
+ await settle();
+ jdbcOption!.dispatchEvent(new MouseEvent("dblclick", { bubbles: true }));
+ await settle();
+ const url = [...document.querySelectorAll<HTMLInputElement>("input")].find((input) => input.placeholder.startsWith("jdbc:"));
+ expect(url).toBeTruthy();
+ url!.value = "jdbc:example://host/db";
+ url!.dispatchEvent(new Event("input", { bubbles: true }));
+ await settle();
+ const save = [...document.querySelectorAll("button")].find((button) => button.textContent?.trim() === "Save");
+ expect(save).toBeTruthy();
+ save!.click();
+ await settle();
+
+ expect(store.addConnection).toHaveBeenCalledWith(
+ expect.objectContaining({
+ db_type: "jdbc",
+ connection_string: "jdbc:example://host/db",
+ host: "",
+ port: 0,
+ }),
+ null,
+ );
+ });
+
it("applies explicit empty passwords and false TLS values without create defaults", async () => {
await mountDialog(savedConnection(), "dbx://connection/new?id=saved-production&password=&ssl=false");
const save = [...document.querySelectorAll("button")].find((button) => button.textContent?.trim() === "Save");
diff --git a/apps/desktop/src/components/editor/QueryEditor.vue b/apps/desktop/src/components/editor/QueryEditor.vue
index f5eddd97ad..dbe2c3b2ff 100644
--- a/apps/desktop/src/components/editor/QueryEditor.vue
+++ b/apps/desktop/src/components/editor/QueryEditor.vue
@@ -34,7 +34,7 @@ import { useQueryEditorCompletionMetadata } from "./useQueryEditorCompletionMeta
import { ref, onMounted, onBeforeUnmount, onActivated, onDeactivated, watch, shallowRef, computed, nextTick } from "vue";
import { useI18n } from "vue-i18n";
-import { Transaction } from "@codemirror/state";
+import { EditorState as CodeMirrorEditorState, Transaction } from "@codemirror/state";
import type { Text } from "@codemirror/state";
import type { EditorView as EditorViewType } from "@codemirror/view";
import { search as cmSearch } from "@codemirror/search";
@@ -2743,6 +2743,18 @@ watch(
},
);
+watch(
+ [view, () => props.tabId, () => props.readOnly],
+ () => {
+ if (!view.value || !codeMirrorRuntime.readOnlyComp || !codeMirrorRuntime.editorViewModule) return;
+ view.value.dispatch({
+ effects: codeMirrorRuntime.readOnlyComp.reconfigure([CodeMirrorEditorState.readOnly.of(!!props.readOnly), codeMirrorRuntime.editorViewModule.EditorView.editable.of(!props.readOnly)]),
+ });
+ },
+ // Reapply after per-tab cached EditorState restoration, even when the prop stays unchanged.
+ { flush: "post" },
+);
+
watch(
() => props.forceWordWrap,
() => {
diff --git a/apps/desktop/src/components/editor/__tests__/QueryEditorReadOnly.integration.spec.ts b/apps/desktop/src/components/editor/__tests__/QueryEditorReadOnly.integration.spec.ts
new file mode 100644
index 0000000000..3678073e9d
--- /dev/null
+++ b/apps/desktop/src/components/editor/__tests__/QueryEditorReadOnly.integration.spec.ts
@@ -0,0 +1,83 @@
+// @vitest-environment happy-dom
+
+import { createApp, h, nextTick, reactive } from "vue";
+import { createPinia, setActivePinia } from "pinia";
+import { createI18n } from "vue-i18n";
+import { EditorView } from "@codemirror/view";
+import { insertNewlineAndIndent, undo } from "@codemirror/commands";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import QueryEditor from "../QueryEditor.vue";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { useConnectionStore } from "@/stores/connectionStore";
+import type { QueryEditorProps } from "../queryEditorTypes";
+
+const cleanups: Array<() => void> = [];
+afterEach(() => {
+ for (const cleanup of cleanups.splice(0).reverse()) cleanup();
+ vi.restoreAllMocks();
+});
+
+async function mountEditor(readOnly: boolean) {
+ const pinia = createPinia();
+ setActivePinia(pinia);
+ useSettingsStore().editorSettings.showExecutionTargetPicker = false;
+ useConnectionStore();
+ const props = reactive<QueryEditorProps>({ modelValue: "SELECT 1;", tabId: "source-a", databaseType: "oceanbase-oracle", dialect: "oracle", autoFocus: false, hideExecutionControls: true, readOnly });
+ const host = document.createElement("div");
+ document.body.append(host);
+ const app = createApp({ render: () => h(QueryEditor, { ...props, "onUpdate:modelValue": (value: string) => (props.modelValue = value) }) });
+ app.use(pinia);
+ app.use(createI18n({ legacy: false, locale: "en", messages: { en: {} }, missingWarn: false, fallbackWarn: false }));
+ app.mount(host);
+ cleanups.push(() => {
+ app.unmount();
+ host.remove();
+ });
+ await vi.waitFor(() => expect(host.querySelector(".cm-editor")).not.toBeNull(), { timeout: 5000 });
+ const view = EditorView.findFromDOM(host.querySelector(".cm-editor") as HTMLElement)!;
+ return { props, view };
+}
+
+function expectReadOnly(view: EditorView, readOnly: boolean) {
+ expect(view.state.readOnly).toBe(readOnly);
+ expect(view.state.facet(EditorView.editable)).toBe(!readOnly);
+ expect(view.contentDOM.getAttribute("contenteditable")).toBe(String(!readOnly));
+}
+
+describe("QueryEditor controlled source editing", () => {
+ it("applies explicit editing and returns to read-only without replacing the view, draft or undo history", async () => {
+ const { props, view } = await mountEditor(true);
+ expectReadOnly(view, true);
+ expect(insertNewlineAndIndent(view)).toBe(false);
+ props.readOnly = false;
+ await nextTick();
+ expectReadOnly(view, false);
+ expect(insertNewlineAndIndent(view)).toBe(true);
+ await nextTick();
+ const edited = view.state.doc.toString();
+ props.readOnly = true;
+ await nextTick();
+ expectReadOnly(view, true);
+ expect(insertNewlineAndIndent(view)).toBe(false);
+ expect(view.state.doc.toString()).toBe(edited);
+ props.readOnly = false;
+ await nextTick();
+ expect(undo(view)).toBe(true);
+ expect(view.state.doc.toString()).toBe("SELECT 1;");
+ });
+
+ it.each([true, false])("rechecks a cached read-only=%s tab when the active prop does not change", async (cachedReadOnly) => {
+ const { props, view } = await mountEditor(cachedReadOnly);
+ props.tabId = "source-b";
+ props.modelValue = "SELECT 2;";
+ await nextTick();
+ props.readOnly = !cachedReadOnly;
+ await nextTick();
+ expectReadOnly(view, !cachedReadOnly);
+ props.tabId = "source-a";
+ props.modelValue = "SELECT 1;";
+ await nextTick();
+ expectReadOnly(view, !cachedReadOnly);
+ expect(view.state.doc.toString()).toBe("SELECT 1;");
+ });
+});
diff --git a/apps/desktop/src/components/layout/AppTabBar.vue b/apps/desktop/src/components/layout/AppTabBar.vue
index d076f7d517..ece6faf901 100644
--- a/apps/desktop/src/components/layout/AppTabBar.vue
+++ b/apps/desktop/src/components/layout/AppTabBar.vue
@@ -70,6 +70,9 @@ function setTabBarTarget(groupId: string, element: unknown) {
const closeConfirmDirtyCount = computed(() => queryStore.closeConfirmDirtyTabIds.length);
const showCloseConfirmBulkActions = computed(() => closeConfirmDirtyCount.value > 1);
const closeConfirmDirtyTabs = computed(() => queryStore.closeConfirmDirtyTabIds.map((id) => queryStore.tabs.find((tab) => tab.id === id)).filter((tab): tab is NonNullable<ReturnType<typeof queryStore.tabs.find>> => !!tab));
+const closeHasTypeRecovery = computed(() => closeConfirmDirtyTabs.value.some((tab) => tab.typeManagementDraft && tab.typeManagementDraft.state !== "complete"));
+const closeConfirmCurrentTab = computed(() => closeConfirmDirtyTabs.value.find((tab) => tab.id === queryStore.pendingCloseTabId) ?? closeConfirmDirtyTabs.value[0]);
+const closeCurrentHasTypeRecovery = computed(() => closeConfirmCurrentTab.value?.typeManagementDraft && closeConfirmCurrentTab.value.typeManagementDraft.state !== "complete");
// Numbered across every open tab so unsaved-change confirmations show the
// same suffixed titles as the tab strip.
const tabTitles = computed(() => tabDisplayTitles(queryStore.tabs, t));
@@ -77,7 +80,7 @@ function closeConfirmTabTitle(tab: QueryTab): string {
return tabTitles.value.get(tab.id) ?? tabDisplayTitle(tab, t);
}
const closeConfirmCurrentTitle = computed(() => {
- const focusedTab = closeConfirmDirtyTabs.value.find((tab) => tab.id === queryStore.pendingCloseTabId) ?? closeConfirmDirtyTabs.value[0];
+ const focusedTab = closeConfirmCurrentTab.value;
return focusedTab ? closeConfirmTabTitle(focusedTab) : "";
});
const closeConfirmMessage = computed(() => {
@@ -242,6 +245,7 @@ function handleCancelClose() {
<!-- 限制最大高度并允许滚动,确保内容超长时底部操作按钮始终可见可点-->
<div class="max-h-120 min-h-0 min-w-0 overflow-y-auto space-y-2">
<p class="wrap-anywhere text-sm text-muted-foreground">{{ closeConfirmMessage }}</p>
+ <p v-if="closeHasTypeRecovery" role="alert" class="wrap-anywhere text-sm text-destructive">{{ t("objects.typeManagementCloseWarning") }}</p>
<Popover v-if="showCloseConfirmBulkActions" :open="closeConfirmListOpen" @update:open="closeConfirmListOpen = $event">
<PopoverTrigger as-child>
<button
@@ -271,9 +275,9 @@ function handleCancelClose() {
<DialogFooter class="min-w-0 sm:flex-wrap">
<Button variant="outline" @click="handleCancelClose">{{ t("common.cancel") }}</Button>
<Button v-if="showCloseConfirmBulkActions" variant="secondary" class="border-border" @click="handleDiscardAllAndClose">{{ t("editor.discardAllChanges") }}</Button>
- <Button v-if="showCloseConfirmBulkActions" @click="handleSaveAllAndClose">{{ t("editor.saveAllChanges") }}</Button>
- <Button variant="secondary" class="border-border" @click="handleDiscardAndClose">{{ t("editor.discardChanges") }}</Button>
- <Button @click="handleSaveAndClose">{{ t("savedSql.save") }}</Button>
+ <Button v-if="showCloseConfirmBulkActions && !closeHasTypeRecovery" @click="handleSaveAllAndClose">{{ t("editor.saveAllChanges") }}</Button>
+ <Button variant="secondary" class="border-border" @click="handleDiscardAndClose">{{ t(closeCurrentHasTypeRecovery ? "objects.typeManagementDiscardClose" : "editor.discardChanges") }}</Button>
+ <Button v-if="!closeCurrentHasTypeRecovery" @click="handleSaveAndClose">{{ t("savedSql.save") }}</Button>
</DialogFooter>
</DialogContent>
</Dialog>
diff --git a/apps/desktop/src/components/layout/ContentArea.vue b/apps/desktop/src/components/layout/ContentArea.vue
index 1c3c271b55..cac3b7edf2 100644
--- a/apps/desktop/src/components/layout/ContentArea.vue
+++ b/apps/desktop/src/components/layout/ContentArea.vue
@@ -220,6 +220,8 @@ import type { QueryMessage, QueryResult, QueryTab, RedisResultViewMode, TableInf
import type { SqlObjectNavigationTarget } from "@/lib/sql/sqlNavigation";
import { sqlFormatDialectForDbType, type SqlFormatDialect } from "@/lib/sql/sqlFormatter";
import { productionContextForDatabase } from "@/lib/database/productionSafety";
+import { isOracleFamilyTypeSource } from "@/lib/database/databaseObjectCapabilities";
+import { requestOracleTypeManagement } from "@/lib/table/oracleTypeManagementRequest";
import { sqlStatementParameterOptionsForCompatibility } from "@/lib/sql/sqlStatementRanges";
import { connectionIsEffectivelyReadOnly } from "@/lib/database/readOnlyWriteAccess";
import { isAiRedisConsoleTarget, type AiConversationBinding } from "@/lib/ai/aiConversationBinding";
@@ -421,6 +423,25 @@ const activeResultDatabase = computed(() => activeResultExecutionTarget.value?.d
const activeResultSchema = computed(() => activeResultExecutionTarget.value?.schema ?? props.activeTab.schema);
const graphViewKey = computed(() => JSON.stringify([props.activeTab.id, props.activeTab.resultViewGeneration, props.activeTab.activeResultRunId, props.activeTab.activeResultIndex, activeResultConnectionId.value, activeResultDatabase.value]));
const activeEffectiveDatabaseType = computed(() => effectiveDatabaseTypeForConnection(activeResultConnection.value));
+const managedTypeSource = computed(() => isOracleFamilyTypeSource(effectiveDatabaseTypeForConnection(props.activeConnection), props.activeTab.objectSource?.objectType));
+const unfinishedTypeChange = computed(() => !!props.activeTab.typeManagementDraft && props.activeTab.typeManagementDraft.state !== "complete");
+const verifiedTypeDeletion = computed(() => props.activeTab.typeManagementDraft?.state === "complete" && props.activeTab.typeManagementDraft.operation.startsWith("delete"));
+function resumeTypeManagement() {
+ const tab = props.activeTab;
+ const draft = tab.typeManagementDraft;
+ if (!draft) return;
+ void requestOracleTypeManagement({
+ target: draft.target,
+ operation: draft.operation,
+ tabId: tab.id,
+ isCurrent: () => queryStore.tabs.includes(tab) && tab.typeManagementDraft?.planId === draft.planId && tab.connectionId === draft.target.connectionId && tab.database === draft.target.database,
+ }).catch((error) => toast(String(error), 5000));
+}
+function refreshTypeSource() {
+ const tab = props.activeTab;
+ if (queryStore.isTabDirty(tab) && !window.confirm(t("objects.refreshDiscardConfirm"))) return;
+ queryStore.retryObjectSourceTab(tab.id);
+}
const activeObjectDependencyTarget = computed(() => {
const tab = props.activeTab;
const details = tab.objectDetails;
@@ -2089,6 +2110,13 @@ defineExpose({
{{ t("contextMenu.viewData") }}
</Button>
</div>
+ <div v-if="managedTypeSource && !activeTab.sourceLoad" class="flex min-h-10 shrink-0 flex-wrap items-center gap-2 border-b px-3 py-1.5" data-type-source-actions>
+ <Button v-if="!activeTab.typeSourceEditing && !unfinishedTypeChange && !verifiedTypeDeletion" variant="outline" size="sm" @click="activeTab.typeSourceEditing = true">{{ t("contextMenu.editObject") }}</Button>
+ <Button v-if="activeTab.typeSourceEditing && !unfinishedTypeChange && !verifiedTypeDeletion" size="sm" @click="emit('saveSql', activeTab.id)">{{ t("objects.typeManagementPreviewSave") }}</Button>
+ <Button v-if="unfinishedTypeChange" variant="outline" size="sm" @click="resumeTypeManagement">{{ t("objects.typeManagementResume") }}</Button>
+ <Button v-if="!unfinishedTypeChange && !verifiedTypeDeletion" variant="outline" size="sm" @click="refreshTypeSource">{{ t("structureEditor.refresh") }}</Button>
+ <span v-if="verifiedTypeDeletion" role="status" class="text-sm text-muted-foreground">{{ t("objects.typeManagementDeleted") }}</span>
+ </div>
<ProductionWatermark v-if="activeProductionContext.active" />
<ObjectDependenciesPanel :target="activeObjectDependencyTarget" :section="activeObjectSection" @update:section="setObjectSection" @view-sql="viewObjectDependencySql" @open-object="(context, target) => emit('openDependencyObject', context, target)">
<!-- issue #9035:源码 tab 先出现再加载。pending 期间不挂载编辑器
@@ -2143,8 +2171,8 @@ defineExpose({
:initial-selection="activeTab.editorSelection"
:reveal-request="activeTab.editorRevealRequest"
:force-word-wrap="activeTab.forceWordWrap"
- :read-only="!!activeTab.ddlViewer"
- :hide-execution-controls="!!activeTab.ddlViewer"
+ :read-only="!!activeTab.ddlViewer || (managedTypeSource && (!activeTab.typeSourceEditing || unfinishedTypeChange || verifiedTypeDeletion))"
+ :hide-execution-controls="!!activeTab.ddlViewer || managedTypeSource"
enable-explain-shortcut
:can-explain="!activeTab.isExecuting && !activeTab.isExplaining && !!executableSql.trim()"
:is-executing="activeTab.isExecuting"
diff --git a/apps/desktop/src/components/layout/EditorGroup.vue b/apps/desktop/src/components/layout/EditorGroup.vue
index c87a879b58..ca6a2a4c8a 100644
--- a/apps/desktop/src/components/layout/EditorGroup.vue
+++ b/apps/desktop/src/components/layout/EditorGroup.vue
@@ -14,6 +14,7 @@ import { createContentSurfaceEventForwarders } from "@/lib/tabs/contentSurfaceEv
import { isPreviewTab } from "@/lib/tabs/tabPresentation";
import { resolveExecutableSql } from "@/lib/sql/sqlExecutionTarget";
import { effectiveDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
+import { isOracleFamilyTypeSource } from "@/lib/database/databaseObjectCapabilities";
import { usesProvenReadOnlyStickyTransactionState } from "@/lib/database/databaseFeatureSupport";
import * as api from "@/lib/backend/api";
import { externalSqlEditorMaxBytes, externalSqlFileOpenErrorMessage } from "@/lib/sql/sqlFileOpen";
@@ -122,7 +123,7 @@ const groupTabs = computed(() => {
});
const activeTab = computed(() => groupTabs.value.find((tab) => tab.id === props.activeTabId) ?? groupTabs.value[0] ?? null);
const activeConnection = computed(() => (activeTab.value ? connectionStore.getConfig(activeTab.value.connectionId) : undefined));
-const showGroupToolbar = computed(() => activeTab.value?.mode === "query" && !activeTab.value.ddlViewer && !isPreviewTab(activeTab.value));
+const showGroupToolbar = computed(() => activeTab.value?.mode === "query" && !activeTab.value.ddlViewer && !isPreviewTab(activeTab.value) && !isOracleFamilyTypeSource(effectiveDatabaseTypeForConnection(activeConnection.value), activeTab.value.objectSource?.objectType));
let encodingRequest = 0;
async function changeExternalSqlEncoding(encoding: NonNullable<QueryTab["externalSqlEncoding"]>) {
diff --git a/apps/desktop/src/components/layout/__tests__/AppTabBar.portal.spec.ts b/apps/desktop/src/components/layout/__tests__/AppTabBar.portal.spec.ts
index 3f60cf4dcf..b7d6eb8e17 100644
--- a/apps/desktop/src/components/layout/__tests__/AppTabBar.portal.spec.ts
+++ b/apps/desktop/src/components/layout/__tests__/AppTabBar.portal.spec.ts
@@ -57,6 +57,8 @@ function mountNavigation(placement: "top" | "bottom" | "left" | "right", empty =
const pages = reactive({ settingsOpen: true, driverOpen: true, driverActive: false, draft: "initial" });
const navigation = reactive({ width: 260, collapsed: false });
const workspace = ref<{ toggleResultsPane: () => boolean } | null>(null);
+ const saveTab = vi.fn();
+ const saveAll = vi.fn();
const active = computed(() => settings.settingsPageActive || pages.driverActive);
const portal = createGroupTabBarPortal(active);
const actions = {
@@ -90,10 +92,10 @@ function mountNavigation(placement: "top" | "bottom" | "left" | "right", empty =
document.body.appendChild(host);
const root = defineComponent({
components: { AppTabBar, SqlEditorWorkspace, TooltipProvider },
- setup: () => ({ store, settings, pages, active, navigation, workspace }),
+ setup: () => ({ store, settings, pages, active, navigation, workspace, saveTab, saveAll }),
template: `
<TooltipProvider>
- <AppTabBar :settings-page-open="pages.settingsOpen" :settings-page-active="settings.settingsPageActive" :driver-store-open="pages.driverOpen" :driver-store-active="pages.driverActive" :tab-bar-width="navigation.width" :tab-bar-collapsed="navigation.collapsed">
+ <AppTabBar :settings-page-open="pages.settingsOpen" :settings-page-active="settings.settingsPageActive" :driver-store-open="pages.driverOpen" :driver-store-active="pages.driverActive" :tab-bar-width="navigation.width" :tab-bar-collapsed="navigation.collapsed" @save-tab="saveTab" @save-all-tab-close="saveAll">
<div v-show="settings.settingsPageActive" data-test="settings-page"><input v-model="pages.draft" data-test="settings-input" /></div>
<div v-show="pages.driverActive" data-test="driver-page">Drivers</div>
</AppTabBar>
@@ -117,7 +119,7 @@ function mountNavigation(placement: "top" | "bottom" | "left" | "right", empty =
host.remove();
window.removeEventListener("dbx:activate-query-surface", onQuerySurface);
});
- return { host, store, settings, pages, portal, actions, warnings, navigation, workspace };
+ return { host, store, settings, pages, portal, actions, warnings, navigation, workspace, saveTab, saveAll };
}
function element(host: HTMLElement, selector: string): HTMLElement {
@@ -134,6 +136,78 @@ describe("AppTabBar group navigation portal", () => {
for (const cleanup of cleanups.splice(0)) cleanup();
});
+ function mixedClose(recoveryFirst = false) {
+ const mounted = mountNavigation("top");
+ mounted.settings.editorSettings.confirmUnsavedSqlClose = true;
+ const [sql, recovery] = mounted.store.tabs;
+ sql!.originalSql = "SELECT 0";
+ recovery!.originalSql = recovery!.sql;
+ recovery!.typeManagementDraft = { state: "stopped" } as NonNullable<QueryTab["typeManagementDraft"]>;
+ mounted.store.closeTabsByIds(recoveryFirst ? [recovery!.id, sql!.id] : [sql!.id, recovery!.id]);
+ return { ...mounted, sql: sql!, recovery: recovery! };
+ }
+
+ function closeButton(label: string) {
+ return [...document.querySelectorAll<HTMLButtonElement>("[role='dialog'] button")].find((button) => button.textContent?.trim() === label);
+ }
+
+ it("keeps the current SQL save action in a mixed TYPE recovery batch", async () => {
+ const { store, sql, recovery, saveTab, saveAll } = mixedClose();
+ await settle();
+ expect(store.pendingCloseTabId).toBe(sql.id);
+ expect(closeButton("editor.discardChanges")).toBeDefined();
+ expect(closeButton("objects.typeManagementDiscardClose")).toBeUndefined();
+ expect(closeButton("editor.saveAllChanges")).toBeUndefined();
+ expect(document.querySelector("[role='alert']")?.textContent).toBe("objects.typeManagementCloseWarning");
+ expect(closeButton("savedSql.save")).toBeDefined();
+ closeButton("savedSql.save")!.click();
+ await settle();
+ expect(saveTab).toHaveBeenCalledExactlyOnceWith(sql.id);
+ expect(saveAll).not.toHaveBeenCalled();
+ expect(store.tabs.find((tab) => tab.id === recovery.id)?.typeManagementDraft).toEqual({ state: "stopped" });
+ expect(sql.sql).toBe("SELECT 1");
+ });
+
+ it.each([false, true])("scopes discard controls to the pending tab (TYPE first: %s)", async (recoveryFirst) => {
+ const { store, sql, recovery } = mixedClose(recoveryFirst);
+ await settle();
+ expect(store.pendingCloseTabId).toBe(recoveryFirst ? recovery.id : sql.id);
+ expect(closeButton(recoveryFirst ? "objects.typeManagementDiscardClose" : "editor.discardChanges")).toBeDefined();
+ expect(!!closeButton("savedSql.save")).toBe(!recoveryFirst);
+ closeButton(recoveryFirst ? "objects.typeManagementDiscardClose" : "editor.discardChanges")!.click();
+ await settle();
+ expect(store.pendingCloseTabId).toBe(recoveryFirst ? sql.id : recovery.id);
+ expect(closeButton(recoveryFirst ? "editor.discardChanges" : "objects.typeManagementDiscardClose")).toBeDefined();
+ expect(!!closeButton("savedSql.save")).toBe(recoveryFirst);
+ expect(store.tabs.map((tab) => tab.id)).toEqual([recoveryFirst ? sql.id : recovery.id]);
+ if (recoveryFirst) expect(store.tabs[0]?.sql).toBe("SELECT 1");
+ else expect(store.tabs[0]?.typeManagementDraft).toEqual({ state: "stopped" });
+ });
+
+ it("cancels a mixed close without discarding SQL or the TYPE recovery draft", async () => {
+ const { store, sql, recovery } = mixedClose();
+ await settle();
+ closeButton("common.cancel")!.click();
+ await settle();
+ expect(store.showCloseConfirm).toBe(false);
+ expect(store.tabs.map((tab) => tab.id)).toEqual([sql.id, recovery.id]);
+ expect(sql.sql).toBe("SELECT 1");
+ expect(recovery.typeManagementDraft).toEqual({ state: "stopped" });
+ });
+
+ it("retains Save All for a batch without unfinished TYPE recovery", async () => {
+ const { store, settings, saveAll } = mountNavigation("top");
+ settings.editorSettings.confirmUnsavedSqlClose = true;
+ for (const tab of store.tabs) tab.originalSql = "SELECT 0";
+ store.tabs[1]!.typeManagementDraft = { state: "complete" } as NonNullable<QueryTab["typeManagementDraft"]>;
+ store.closeTabsByIds(store.tabs.map((tab) => tab.id));
+ await settle();
+ expect(closeButton("savedSql.save")).toBeDefined();
+ expect(closeButton("editor.saveAllChanges")).toBeDefined();
+ closeButton("editor.saveAllChanges")!.click();
+ expect(saveAll).toHaveBeenCalledOnce();
+ });
+
it.each(["top", "bottom", "left", "right"] as const)("moves the same %s bar between query, settings and driver surfaces", async (placement) => {
const { host, pages, warnings } = mountNavigation(placement);
await settle();
diff --git a/apps/desktop/src/components/objects/CustomTypeInfoPanel.vue b/apps/desktop/src/components/objects/CustomTypeInfoPanel.vue
index 3e2aac77f1..e5c5018333 100644
--- a/apps/desktop/src/components/objects/CustomTypeInfoPanel.vue
+++ b/apps/desktop/src/components/objects/CustomTypeInfoPanel.vue
@@ -1,13 +1,14 @@
<script setup lang="ts">
-import { computed, ref, watch } from "vue";
+import { computed, onBeforeUnmount, ref, watch } from "vue";
import { useI18n } from "vue-i18n";
import { Copy, RefreshCw, X } from "@lucide/vue";
import { Button } from "@/components/ui/button";
import { createSidePanelRequestGuard } from "@/lib/table/sidePanelRequestGuard";
+import { metadataLoadBudgetMs } from "@/lib/metadata/metadataLoadBudget";
import { copyToClipboard } from "@/lib/common/clipboard";
import { useToast } from "@/composables/useToast";
import { translateBackendError } from "@/i18n/backend-errors";
-import type { ConnectionConfig, CustomTypeDetails, CustomTypeKind } from "@/types/database";
+import type { ConnectionConfig, CustomTypeDetails, CustomTypeKind, DatabaseType, ObjectSourceKind, TypeMetadataRead } from "@/types/database";
import * as api from "@/lib/backend/api";
const props = defineProps<{
@@ -16,57 +17,97 @@ const props = defineProps<{
schema: string;
name: string;
catalog?: string;
+ databaseType?: DatabaseType;
}>();
-const emit = defineEmits<{ close: [] }>();
+const emit = defineEmits<{ close: []; "open-source": [objectType: "TYPE" | "TYPE_BODY"] }>();
const { t } = useI18n();
const toast = useToast();
+type CustomTypeTabId = "members" | "properties" | "methods" | "ddl" | "source";
+type CustomTypeTab = { id: CustomTypeTabId; label: string };
const guard = createSidePanelRequestGuard();
+const sourceGuard = createSidePanelRequestGuard();
const details = ref<CustomTypeDetails | null>(null);
const loading = ref(false);
const error = ref<string | null>(null);
-const tab = ref<"members" | "properties" | "ddl">("members");
+const sourceLoading = ref(false);
+const sourceError = ref<string | null>(null);
+const sourceText = ref("");
+const sourceObjectType = ref<"TYPE" | "TYPE_BODY">("TYPE");
+const tab = ref<"members" | "properties" | "methods" | "ddl" | "source">("members");
+const userSelectedTab = ref(false);
+const dbType = computed(() => props.databaseType ?? props.connection.db_type);
+const isOracleFamily = computed(() => ["oracle", "oceanbase-oracle", "dameng"].includes(dbType.value));
-const kindLabel = computed(() => (details.value ? t(`customType.kinds.${details.value.kind}`) : ""));
-const hasMemberTab = computed(() => details.value?.kind === "composite" || details.value?.kind === "enum");
-const tabs = computed(() => {
- const items: Array<{ id: "members" | "properties" | "ddl"; label: string }> = [];
+const kindLabel = computed(() => (details.value ? t(details.value.oracleMetadata ? `oracleType.kinds.${details.value.kind}` : `customType.kinds.${details.value.kind}`) : ""));
+const hasMemberTab = computed(() => details.value?.kind === "composite" || details.value?.kind === "enum" || !!details.value?.oracleMetadata);
+const tabs = computed<CustomTypeTab[]>(() => {
+ const items: CustomTypeTab[] = [];
if (hasMemberTab.value) items.push({ id: "members", label: t("customType.tabs.members") });
+ if (!details.value && isOracleFamily.value) {
+ const sourceTab: CustomTypeTab = { id: "source", label: t("oracleType.source") };
+ return [sourceTab];
+ }
items.push({ id: "properties", label: t("customType.tabs.properties") });
- items.push({ id: "ddl", label: t("customType.tabs.ddl") });
+ if (details.value?.oracleMetadata) {
+ items.push({ id: "methods", label: t("oracleType.methods") });
+ items.push({ id: "source", label: t("oracleType.source") });
+ } else if (isOracleFamily.value) {
+ items.push({ id: "source", label: t("oracleType.source") });
+ } else {
+ items.push({ id: "ddl", label: t("customType.tabs.ddl") });
+ }
return items;
});
-async function load() {
+async function load(preserveDetails = false) {
// start() bumps the epoch so an in-flight request from a previously selected
// type can never overwrite the current panel state.
const epoch = guard.start();
loading.value = true;
error.value = null;
- details.value = null;
- tab.value = "members";
+ if (!preserveDetails) details.value = null;
try {
- const result = await api.getCustomTypeDetails(props.connection.id, props.database, props.schema, props.name);
+ const result = await guard.wait(epoch, api.getCustomTypeDetails(props.connection.id, props.database, props.schema, props.name), metadataLoadBudgetMs(props.connection.query_timeout_secs));
if (guard.isStale(epoch)) return;
details.value = result;
- if (tab.value === "members" && result.kind !== "composite" && result.kind !== "enum") {
+ if (!userSelectedTab.value && isOracleFamily.value && result.oracleMetadata) tab.value = result.kind === "collection" ? "properties" : "members";
+ if (!userSelectedTab.value && tab.value === "members" && result.kind !== "composite" && result.kind !== "enum" && !result.oracleMetadata) {
tab.value = "properties";
}
} catch (e: any) {
if (guard.isStale(epoch)) return;
error.value = e?.message || String(e);
+ if (!details.value && isOracleFamily.value) {
+ tab.value = "source";
+ }
} finally {
if (guard.isFresh(epoch)) loading.value = false;
}
}
watch(
- () => [props.connection.id, props.database, props.schema, props.name] as const,
- () => load(),
+ () => [props.connection.id, props.database, props.schema, props.name, dbType.value] as const,
+ () => {
+ sourceGuard.bump();
+ sourceLoading.value = false;
+ sourceError.value = null;
+ sourceText.value = "";
+ sourceObjectType.value = "TYPE";
+ userSelectedTab.value = false;
+ tab.value = isOracleFamily.value ? "source" : "members";
+ void load();
+ if (isOracleFamily.value) void loadSource("TYPE");
+ },
{ immediate: true },
);
+onBeforeUnmount(() => {
+ guard.bump();
+ sourceGuard.bump();
+});
+
const ddlText = computed(() => details.value?.ddl?.sql ?? "");
async function copyDdl() {
@@ -109,28 +150,111 @@ function isEnumKind(kind: CustomTypeKind | undefined): boolean {
return kind === "enum";
}
-function selectTab(next: "members" | "properties" | "ddl") {
+function selectTab(next: CustomTypeTabId) {
+ userSelectedTab.value = true;
tab.value = next;
+ if (next === "source" && !sourceText.value && !sourceLoading.value && !sourceError.value) {
+ void loadSource(sourceObjectType.value);
+ }
+}
+
+async function loadSource(objectType: "TYPE" | "TYPE_BODY", preserveSource = false) {
+ const epoch = sourceGuard.start();
+ const connectionId = props.connection.id;
+ const database = props.database;
+ const schema = props.schema;
+ const name = props.name;
+ sourceObjectType.value = objectType;
+ sourceLoading.value = true;
+ sourceError.value = null;
+ if (!preserveSource) sourceText.value = "";
+ try {
+ const result = await sourceGuard.wait(epoch, api.getObjectSource(connectionId, database, schema, name, objectType as ObjectSourceKind), metadataLoadBudgetMs(props.connection.query_timeout_secs));
+ if (sourceGuard.isStale(epoch)) return;
+ sourceText.value = result.source;
+ } catch (e: any) {
+ if (sourceGuard.isStale(epoch)) return;
+ sourceError.value = e?.message || String(e);
+ } finally {
+ if (sourceGuard.isFresh(epoch)) sourceLoading.value = false;
+ }
+}
+
+function refresh() {
+ const objectType = sourceObjectType.value;
+ sourceGuard.bump();
+ void load(true);
+ if (isOracleFamily.value) void loadSource(objectType, true);
}
-defineExpose({ selectTab });
+function viewBodySource() {
+ sourceObjectType.value = "TYPE_BODY";
+ tab.value = "source";
+ void loadSource("TYPE_BODY");
+}
+
+async function copySource() {
+ if (!sourceText.value) return;
+ try {
+ await copyToClipboard(sourceText.value);
+ toast.toast(t("contextMenu.ddlCopied"));
+ } catch (error) {
+ toast.toast(t("grid.copyFailed", { message: translateBackendError(t, error) }));
+ }
+}
+
+function readStateLabel(read: TypeMetadataRead): string {
+ return t(`oracleType.read.${read.state}`);
+}
+
+function readReason(read: TypeMetadataRead): string {
+ return read.reason || "";
+}
+
+const oraclePropertyRows = computed<Array<{ label: string; value: string }>>(() => {
+ const metadata = details.value?.oracleMetadata;
+ if (!metadata) return [];
+ const rows: Array<{ label: string; value: string }> = [];
+ const add = (key: string, value: unknown) => {
+ if (value !== null && value !== undefined && value !== "") rows.push({ label: t(`oracleType.${key}`), value: String(value) });
+ };
+ add("owner", details.value?.schema);
+ add("status", metadata.status ?? t("oracleType.unknown"));
+ add("typeCode", metadata.typeCode);
+ add("isFinal", metadata.isFinal == null ? null : t(metadata.isFinal ? "oracleType.boolean.yes" : "oracleType.boolean.no"));
+ add("instantiable", metadata.instantiable == null ? null : t(metadata.instantiable ? "oracleType.boolean.yes" : "oracleType.boolean.no"));
+ add("supertype", metadata.supertypeName ? [metadata.supertypeOwner, metadata.supertypeName].filter(Boolean).join(".") : null);
+ add("attributeCount", metadata.attributeCount);
+ add("methodCount", metadata.methodCount);
+ add("bodyStatus", metadata.bodyStatus);
+ if (metadata.bodyRead.state === "available") {
+ const visibilityKey = metadata.bodyVisible === true ? "oracleType.bodyVisible" : metadata.bodyVisible === false ? "oracleType.bodyNotVisible" : "oracleType.unknown";
+ add("bodyVisibility", t(visibilityKey));
+ }
+ return rows;
+});
+
+defineExpose({ selectTab, refresh });
</script>
<template>
<div class="flex h-full min-h-0 flex-col">
<div class="flex items-center gap-2 border-b px-3 py-1.5 bg-muted/20 h-9 shrink-0">
<span class="text-xs font-medium flex-1 min-w-0 truncate">{{ name }}</span>
- <span class="rounded border border-border bg-background px-1.5 py-0.5 text-[10px] text-muted-foreground shrink-0">{{ kindLabel }}</span>
+ <span class="rounded border border-border bg-background px-1.5 py-0.5 text-[10px] text-muted-foreground shrink-0">{{ kindLabel || details?.oracleMetadata?.typeCode || "" }}</span>
+ <Button v-if="isOracleFamily && details" variant="ghost" size="icon" class="h-6 w-6" :title="t('common.retry')" :aria-label="t('common.retry')" @click="refresh">
+ <RefreshCw class="w-3 h-3" />
+ </Button>
<Button variant="ghost" size="icon" class="h-6 w-6" @click="emit('close')">
<X class="w-3 h-3" />
</Button>
</div>
- <div v-if="loading" class="flex-1 flex items-center justify-center text-xs text-muted-foreground">
+ <div v-if="loading && !details" class="flex-1 flex items-center justify-center text-xs text-muted-foreground" role="status" aria-live="polite">
{{ t("common.loading") }}
</div>
- <div v-else-if="error" class="flex-1 flex flex-col items-center justify-center gap-2 px-4 text-center">
+ <div v-else-if="error && !details && !isOracleFamily" class="flex-1 flex flex-col items-center justify-center gap-2 px-4 text-center" role="alert">
<div class="text-xs text-destructive break-words max-w-full">{{ error }}</div>
<Button variant="outline" size="sm" class="h-6 text-xs" @click="load">
<RefreshCw class="w-3 h-3" />
@@ -138,9 +262,16 @@ defineExpose({ selectTab });
</Button>
</div>
- <template v-else-if="details">
+ <template v-if="details || (isOracleFamily && (loading || error))">
<div class="flex items-center gap-1 border-b px-2 py-1 shrink-0">
- <button v-for="item in tabs" :key="item.id" type="button" class="rounded px-2 py-1 text-xs" :class="tab === item.id ? 'bg-accent text-foreground' : 'text-muted-foreground hover:text-foreground'" @click="tab = item.id">
+ <button
+ v-for="item in tabs"
+ :key="item.id"
+ type="button"
+ class="rounded px-2 py-1 text-xs focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+ :class="tab === item.id ? 'bg-accent text-foreground' : 'text-muted-foreground hover:text-foreground'"
+ @click="selectTab(item.id)"
+ >
{{ item.label }}
</button>
<span class="flex-1" />
@@ -150,63 +281,185 @@ defineExpose({ selectTab });
</Button>
</div>
- <div class="flex-1 min-h-0 overflow-auto">
- <!-- Members: empty state for composite/enum -->
- <div v-if="tab === 'members' && details.members.length === 0" class="flex flex-col items-center justify-center gap-1 px-4 py-8 text-center">
- <span class="text-xs text-muted-foreground">{{ t("customType.members.empty") }}</span>
+ <div class="flex-1 min-h-0 overflow-auto" :aria-busy="loading || sourceLoading">
+ <div v-if="error" class="flex items-center gap-2 border-b border-destructive/30 bg-destructive/5 px-3 py-2 text-xs text-destructive" role="alert">
+ <span class="flex-1">{{ error }}</span>
+ <Button v-if="!details" variant="outline" size="sm" class="h-6 text-xs" @click="load">{{ t("common.retry") }}</Button>
</div>
+ <div v-if="loading" class="border-b px-3 py-1 text-xs text-muted-foreground" role="status" aria-live="polite">{{ t("common.loading") }}</div>
+ <!-- Members: empty state for composite/enum -->
+ <template v-if="details">
+ <div v-if="tab === 'members' && details.oracleMetadata && details.oracleMetadata.attributesRead.state !== 'available'" class="border-b px-3 py-2 text-xs text-muted-foreground">
+ <strong>{{ readStateLabel(details.oracleMetadata.attributesRead) }}</strong
+ ><span v-if="readReason(details.oracleMetadata.attributesRead)"> · {{ readReason(details.oracleMetadata.attributesRead) }}</span>
+ </div>
+ <div
+ v-if="tab === 'members' && details.oracleMetadata && details.kind !== 'collection' && details.oracleMetadata.attributesRead.state === 'available' && details.oracleMetadata.attributes.length === 0"
+ class="flex flex-col items-center justify-center gap-1 px-4 py-8 text-center text-xs text-muted-foreground"
+ >
+ {{ t("oracleType.emptyAttributes") }}
+ </div>
+ <div v-else-if="tab === 'members' && !details.oracleMetadata && details.members.length === 0" class="flex flex-col items-center justify-center gap-1 px-4 py-8 text-center">
+ <span class="text-xs text-muted-foreground">{{ t("customType.members.empty") }}</span>
+ </div>
+
+ <table v-if="tab === 'members' && details.oracleMetadata && details.oracleMetadata.attributes.length > 0" class="w-full text-[11px]">
+ <thead class="sticky top-0 bg-muted/40 text-left text-muted-foreground">
+ <tr>
+ <th class="px-3 py-1.5 font-medium">#</th>
+ <th class="px-3 py-1.5 font-medium">{{ t("customType.members.name") }}</th>
+ <th class="px-3 py-1.5 font-medium">{{ t("customType.members.type") }}</th>
+ <th class="px-3 py-1.5 font-medium">{{ t("oracleType.length") }}</th>
+ <th class="px-3 py-1.5 font-medium">{{ t("oracleType.precision") }}</th>
+ <th class="px-3 py-1.5 font-medium">{{ t("oracleType.scale") }}</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr v-for="(attribute, index) in details.oracleMetadata.attributes" :key="`${attribute.ordinal ?? index}:${attribute.name}`" class="border-t border-border/60">
+ <td class="px-3 py-1.5 text-muted-foreground">{{ attribute.ordinal ?? "—" }}</td>
+ <td class="px-3 py-1.5 font-mono">{{ attribute.name }}</td>
+ <td class="px-3 py-1.5 font-mono">{{ [attribute.typeOwner, attribute.typeName, attribute.typeModifier].filter(Boolean).join(".") || "—" }}</td>
+ <td class="px-3 py-1.5">{{ attribute.length ?? "—" }}</td>
+ <td class="px-3 py-1.5">{{ attribute.precision ?? "—" }}</td>
+ <td class="px-3 py-1.5">{{ attribute.scale ?? "—" }}</td>
+ </tr>
+ </tbody>
+ </table>
+ <!-- Members: composite fields -->
+ <table v-else-if="tab === 'members' && isFieldKind(details.kind)" class="w-full text-[11px]">
+ <thead class="sticky top-0 bg-muted/40 text-left text-muted-foreground">
+ <tr>
+ <th class="px-3 py-1.5 font-medium">#</th>
+ <th class="px-3 py-1.5 font-medium">{{ t("customType.members.name") }}</th>
+ <th class="px-3 py-1.5 font-medium">{{ t("customType.members.type") }}</th>
+ <th class="px-3 py-1.5 font-medium">{{ t("customType.members.nullable") }}</th>
+ <th class="px-3 py-1.5 font-medium">{{ t("customType.members.default") }}</th>
+ <th class="px-3 py-1.5 font-medium">{{ t("customType.members.comment") }}</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr v-for="member in details.members" :key="member.ordinal" class="border-t border-border/60">
+ <td class="px-3 py-1.5 text-muted-foreground">{{ member.ordinal }}</td>
+ <td class="px-3 py-1.5 font-mono">{{ member.name }}</td>
+ <td class="px-3 py-1.5 font-mono">{{ member.dataType }}</td>
+ <td class="px-3 py-1.5">{{ member.nullable == null ? "—" : member.nullable ? "✓" : "✗" }}</td>
+ <td class="px-3 py-1.5 font-mono">{{ member.default ?? "—" }}</td>
+ <td class="px-3 py-1.5">{{ member.comment ?? "—" }}</td>
+ </tr>
+ </tbody>
+ </table>
- <!-- Members: composite fields -->
- <table v-else-if="tab === 'members' && isFieldKind(details.kind)" class="w-full text-[11px]">
- <thead class="sticky top-0 bg-muted/40 text-left text-muted-foreground">
- <tr>
- <th class="px-3 py-1.5 font-medium">#</th>
- <th class="px-3 py-1.5 font-medium">{{ t("customType.members.name") }}</th>
- <th class="px-3 py-1.5 font-medium">{{ t("customType.members.type") }}</th>
- <th class="px-3 py-1.5 font-medium">{{ t("customType.members.nullable") }}</th>
- <th class="px-3 py-1.5 font-medium">{{ t("customType.members.default") }}</th>
- <th class="px-3 py-1.5 font-medium">{{ t("customType.members.comment") }}</th>
- </tr>
- </thead>
- <tbody>
- <tr v-for="member in details.members" :key="member.ordinal" class="border-t border-border/60">
- <td class="px-3 py-1.5 text-muted-foreground">{{ member.ordinal }}</td>
- <td class="px-3 py-1.5 font-mono">{{ member.name }}</td>
- <td class="px-3 py-1.5 font-mono">{{ member.dataType }}</td>
- <td class="px-3 py-1.5">{{ member.nullable == null ? "—" : member.nullable ? "✓" : "✗" }}</td>
- <td class="px-3 py-1.5 font-mono">{{ member.default ?? "—" }}</td>
- <td class="px-3 py-1.5">{{ member.comment ?? "—" }}</td>
- </tr>
- </tbody>
- </table>
-
- <!-- Members: enum values -->
- <ul v-else-if="tab === 'members' && isEnumKind(details.kind) && details.members.length > 0" class="divide-y divide-border/60">
- <li v-for="member in details.members" :key="member.ordinal" class="flex items-center gap-3 px-3 py-1.5 text-[11px]">
- <span class="w-6 text-muted-foreground text-right">{{ member.ordinal }}</span>
- <span class="font-mono">{{ member.enumValue }}</span>
- </li>
- </ul>
-
- <!-- Properties -->
- <table v-else-if="tab === 'properties'" class="w-full text-[11px]">
- <tbody>
- <tr v-if="details.comment" class="border-b border-border/60">
- <td class="px-3 py-1.5 text-muted-foreground w-44">{{ t("customType.members.comment") }}</td>
- <td class="px-3 py-1.5">{{ details.comment }}</td>
- </tr>
- <tr v-for="row in propertyRows" :key="row.label" class="border-b border-border/60">
- <td class="px-3 py-1.5 text-muted-foreground w-44 align-top">{{ row.label }}</td>
- <td class="px-3 py-1.5 font-mono whitespace-pre-wrap break-all">{{ row.value }}</td>
- </tr>
- <tr v-if="propertyRows.length === 0 && !details.comment" class="border-b border-border/60">
- <td class="px-3 py-2 text-xs text-muted-foreground" colspan="2">{{ t("customType.properties.empty") }}</td>
- </tr>
- </tbody>
- </table>
+ <!-- Members: enum values -->
+ <ul v-else-if="tab === 'members' && isEnumKind(details.kind) && details.members.length > 0" class="divide-y divide-border/60">
+ <li v-for="member in details.members" :key="member.ordinal" class="flex items-center gap-3 px-3 py-1.5 text-[11px]">
+ <span class="w-6 text-muted-foreground text-right">{{ member.ordinal }}</span>
+ <span class="font-mono">{{ member.enumValue }}</span>
+ </li>
+ </ul>
+ <!-- Properties -->
+ <table v-else-if="tab === 'properties'" class="w-full text-[11px]">
+ <tbody>
+ <template v-if="details.oracleMetadata">
+ <tr v-for="row in oraclePropertyRows" :key="row.label" class="border-b border-border/60">
+ <td class="px-3 py-1.5 text-muted-foreground w-44 align-top">{{ row.label }}</td>
+ <td class="px-3 py-1.5 font-mono whitespace-pre-wrap break-all">{{ row.value }}</td>
+ </tr>
+ <tr
+ v-for="section in [
+ { key: 'propertiesRead', read: details.oracleMetadata.propertiesRead },
+ { key: 'bodyRead', read: details.oracleMetadata.bodyRead },
+ ]"
+ :key="section.key"
+ class="border-b border-border/60"
+ >
+ <td class="px-3 py-1.5 text-muted-foreground w-44 align-top">{{ t(`oracleType.${section.key}`) }}</td>
+ <td class="px-3 py-1.5">
+ <span>{{ readStateLabel(section.read) }}</span
+ ><span v-if="readReason(section.read)"> · {{ readReason(section.read) }}</span>
+ </td>
+ </tr>
+ <tr v-if="details.oracleMetadata.bodyVisible === true" class="border-b border-border/60">
+ <td class="px-3 py-1.5 text-muted-foreground w-44">{{ t("oracleType.body") }}</td>
+ <td class="px-3 py-1.5">
+ <Button variant="ghost" size="sm" class="h-6 px-2 text-xs" @click="viewBodySource">{{ t("oracleType.viewBody") }}</Button>
+ </td>
+ </tr>
+ <tr v-if="details.oracleMetadata.collection">
+ <td class="px-3 py-1.5 text-muted-foreground w-44 align-top">{{ t("oracleType.collection") }}</td>
+ <td class="px-3 py-1.5 font-mono">
+ {{ [details.oracleMetadata.collection.kind, details.oracleMetadata.collection.elementOwner, details.oracleMetadata.collection.elementName, details.oracleMetadata.collection.elementModifier].filter(Boolean).join(" · ")
+ }}<span v-if="details.oracleMetadata.collection.upperBound != null"> · {{ t("oracleType.upperBound") }}: {{ details.oracleMetadata.collection.upperBound }}</span
+ ><span v-if="details.oracleMetadata.collection.length != null"> · {{ t("oracleType.length") }}: {{ details.oracleMetadata.collection.length }}</span
+ ><span v-if="details.oracleMetadata.collection.precision != null"> · {{ t("oracleType.precision") }}: {{ details.oracleMetadata.collection.precision }}</span
+ ><span v-if="details.oracleMetadata.collection.scale != null"> · {{ t("oracleType.scale") }}: {{ details.oracleMetadata.collection.scale }}</span>
+ </td>
+ </tr>
+ <tr v-if="details.kind === 'collection' && details.oracleMetadata.collectionRead.state !== 'available'" class="border-b border-border/60">
+ <td class="px-3 py-1.5 text-muted-foreground w-44">{{ t("oracleType.collection") }}</td>
+ <td class="px-3 py-1.5 text-muted-foreground">
+ <span>{{ readStateLabel(details.oracleMetadata.collectionRead) }}</span
+ ><span v-if="readReason(details.oracleMetadata.collectionRead)"> · {{ readReason(details.oracleMetadata.collectionRead) }}</span>
+ </td>
+ </tr>
+ </template>
+ <tr v-if="details.comment" class="border-b border-border/60">
+ <td class="px-3 py-1.5 text-muted-foreground w-44">{{ t("customType.members.comment") }}</td>
+ <td class="px-3 py-1.5">{{ details.comment }}</td>
+ </tr>
+ <tr v-for="row in propertyRows" :key="row.label" class="border-b border-border/60">
+ <td class="px-3 py-1.5 text-muted-foreground w-44 align-top">{{ row.label }}</td>
+ <td class="px-3 py-1.5 font-mono whitespace-pre-wrap break-all">{{ row.value }}</td>
+ </tr>
+ <tr v-if="propertyRows.length === 0 && oraclePropertyRows.length === 0 && !details.oracleMetadata?.collection && !details.comment" class="border-b border-border/60">
+ <td class="px-3 py-2 text-xs text-muted-foreground" colspan="2">{{ t("customType.properties.empty") }}</td>
+ </tr>
+ </tbody>
+ </table>
+
+ <section v-else-if="tab === 'methods' && details.oracleMetadata" class="p-3 text-xs">
+ <div class="mb-3 flex items-center justify-between border-b pb-2">
+ <strong>{{ t("oracleType.methodMetadata") }}</strong
+ ><span
+ >{{ readStateLabel(details.oracleMetadata.methodsRead) }}<span v-if="readReason(details.oracleMetadata.methodsRead)"> · {{ readReason(details.oracleMetadata.methodsRead) }}</span></span
+ >
+ </div>
+ <p v-if="details.oracleMetadata.methodsRead.state === 'available' && details.oracleMetadata.methods.length === 0" class="py-4 text-center text-muted-foreground">{{ t("oracleType.emptyMethods") }}</p>
+ <article v-for="(method, index) in details.oracleMetadata.methods" :key="`${method.number ?? index}:${method.name}`" class="mb-3 rounded border p-2">
+ <div class="flex flex-wrap items-baseline gap-x-2">
+ <strong class="font-mono">{{ method.name }}</strong
+ ><span v-if="method.kind" class="text-muted-foreground">{{ method.kind }}</span
+ ><span v-if="method.number != null" class="text-muted-foreground">#{{ method.number }}</span>
+ </div>
+ <div class="mt-2 grid gap-1" v-if="method.parameters.length || method.results.length || method.parametersRead.state !== 'available' || method.resultsRead.state !== 'available'">
+ <div v-for="parameter in method.parameters" :key="`p:${parameter.ordinal ?? ''}:${parameter.name ?? ''}`" class="font-mono text-muted-foreground">
+ {{ parameter.mode || t("oracleType.parameter") }} {{ parameter.name || "—" }}: {{ [parameter.typeOwner, parameter.typeName, parameter.typeModifier].filter(Boolean).join(".") || "—" }}
+ </div>
+ <div v-if="method.parametersRead.state !== 'available'" class="text-muted-foreground">
+ {{ t("oracleType.parameters") }}: {{ readStateLabel(method.parametersRead) }}<span v-if="readReason(method.parametersRead)"> · {{ readReason(method.parametersRead) }}</span>
+ </div>
+ <div v-for="result in method.results" :key="`r:${result.ordinal ?? ''}:${result.name ?? ''}`" class="font-mono text-muted-foreground">
+ {{ t("oracleType.result") }} {{ result.name || "—" }}: {{ [result.typeOwner, result.typeName, result.typeModifier].filter(Boolean).join(".") || "—" }}
+ </div>
+ <div v-if="method.resultsRead.state !== 'available'" class="text-muted-foreground">
+ {{ t("oracleType.results") }}: {{ readStateLabel(method.resultsRead) }}<span v-if="readReason(method.resultsRead)"> · {{ readReason(method.resultsRead) }}</span>
+ </div>
+ </div>
+ </article>
+ </section>
+ </template>
+ <section v-if="tab === 'source'" class="flex h-full min-h-0 flex-col">
+ <div class="flex items-center gap-2 border-b px-3 py-1.5 text-xs">
+ <span class="flex-1 font-medium">{{ sourceObjectType === "TYPE_BODY" ? t("oracleType.bodySource") : t("oracleType.source") }}</span
+ ><Button v-if="sourceError" variant="outline" size="sm" class="h-6 text-xs" @click="loadSource(sourceObjectType)">{{ t("common.retry") }}</Button
+ ><Button v-if="sourceText" variant="ghost" size="sm" class="h-6 px-2 text-xs" @click="copySource"><Copy class="mr-1 h-3 w-3" />{{ t("grid.copyDdl") }}</Button>
+ </div>
+ <div v-if="sourceLoading && !sourceText" class="flex flex-1 items-center justify-center text-xs text-muted-foreground" role="status" aria-live="polite">{{ t("common.loading") }}</div>
+ <div v-if="sourceError" class="flex items-center justify-center px-4 py-2 text-center text-xs text-destructive" role="alert">{{ sourceError }}</div>
+ <pre v-if="sourceText" class="min-h-0 flex-1 overflow-auto whitespace-pre-wrap break-words p-3 font-mono text-[11px] leading-relaxed">{{ sourceText }}</pre>
+ </section>
<!-- DDL -->
- <div v-else class="flex h-full flex-col">
+ <div v-if="details && tab === 'ddl'" class="flex h-full flex-col">
<div v-if="details.ddl && !details.ddl.complete" class="border-b border-amber-500/30 bg-amber-500/10 px-3 py-1.5">
<div v-for="warning in details.ddl.warnings" :key="warning" class="text-[11px] text-amber-600 dark:text-amber-400">{{ warning }}</div>
</div>
diff --git a/apps/desktop/src/components/objects/ObjectBrowser.vue b/apps/desktop/src/components/objects/ObjectBrowser.vue
index 34d098cf5c..9186588f09 100644
--- a/apps/desktop/src/components/objects/ObjectBrowser.vue
+++ b/apps/desktop/src/components/objects/ObjectBrowser.vue
@@ -190,7 +190,8 @@ import {
} from "@/lib/table/objectBrowserRows";
import { isSourceOnlyObjectBrowserRow, resolveRowClickAction, shouldDeferSingleClick, singleClickRowAction, type ObjectBrowserRowAction } from "@/lib/table/objectBrowserRowAction";
import { objectBrowserTableSelectionAnchor, objectBrowserTableSelectionRange } from "@/lib/table/objectBrowserSelection";
-import { customTypeCapabilities, sidebarObjectKindsForDatabase, supportsSchemaIndexManagement, supportsTypeObjectSource, type SidebarObjectKind } from "@/lib/database/databaseObjectCapabilities";
+import { customTypeCapabilities, isOracleFamilyTypeSource, sidebarObjectKindsForDatabase, supportsOracleFamilyTypeManagement, supportsSchemaIndexManagement, supportsTypeObjectSource, type SidebarObjectKind } from "@/lib/database/databaseObjectCapabilities";
+import { requestOracleTypeManagement } from "@/lib/table/oracleTypeManagementRequest";
import { schemaIndexIdentity, schemaIndexIsSameOwner } from "@/lib/table/schemaIndexNavigation";
import { connectionConfigFingerprint } from "@/lib/connection/connectionDatabaseInfo";
import { filterObjectBrowserTableColumns } from "@/lib/table/objectBrowserTableInfo";
@@ -1800,6 +1801,10 @@ async function refreshActiveTableInfo() {
await refreshActiveSource();
return;
}
+ if (sidePanelMode.value === "type-info") {
+ await sidePanelRef.value?.refresh();
+ return;
+ }
if (sidePanelMode.value !== "table-info" || !sidePanelRow.value) return;
sidePanelGuard.bump();
@@ -2000,7 +2005,7 @@ async function openInvalidObjectSource(object: { owner: string; name: string; ty
props.database === database &&
props.catalog === catalog &&
(selectedSchema.value || props.database) === schema;
- if (objectType === "TYPE" || objectType === "TYPE_BODY" || objectType === "TRIGGER") {
+ if (objectType === "TRIGGER") {
try {
const source = await api.getObjectSource(connection.id, database, object.owner, object.name, objectType);
if (!isCurrentRequest()) return;
@@ -2088,7 +2093,7 @@ async function loadSourcePanel(row: ObjectBrowserRow, options?: { preserveEditin
try {
const result = await sidePanelGuard.wait(epoch, api.getObjectSource(connectionId, database, schema, row.name, row.type as ObjectSourceKind, row.signature ?? undefined), metadataLoadBudgetMs(props.connection.query_timeout_secs));
if (sidePanelGuard.isStale(epoch)) return;
- sourceCanEdit.value = result.editable !== false && !["TRIGGER", "TYPE", "TYPE_BODY"].includes(row.type) && (row.type !== "SEQUENCE" || effectiveDatabaseType.value === "oceanbase-oracle");
+ sourceCanEdit.value = result.editable !== false && (!["TRIGGER", "TYPE", "TYPE_BODY"].includes(row.type) || isOracleFamilyTypeSource(effectiveDatabaseType.value, row.type)) && (row.type !== "SEQUENCE" || effectiveDatabaseType.value === "oceanbase-oracle");
const editable = sourceCanEdit.value
? await sidePanelGuard.wait(
epoch,
@@ -2110,7 +2115,7 @@ async function loadSourcePanel(row: ObjectBrowserRow, options?: { preserveEditin
sourceContent.value = row.type === "SEQUENCE" ? result.source : editable;
sourceDraft.value = editable;
// Fresh open always enters edit when allowed; refresh preserves prior edit mode.
- const enterEditing = sourceCanEdit.value && row.type !== "SEQUENCE" && (options?.preserveEditing ? preserveEditing : true);
+ const enterEditing = sourceCanEdit.value && row.type !== "SEQUENCE" && (options?.preserveEditing ? preserveEditing : !isOracleFamilyTypeSource(effectiveDatabaseType.value, row.type));
sourceEditing.value = enterEditing;
if (!sourceCanEdit.value && row.type !== "SEQUENCE") {
toast(t("objects.sourceReadOnly"), 3000);
@@ -2220,6 +2225,10 @@ function requestDrop(row: ObjectBrowserRow) {
openSchemaIndexEditor(row, "delete");
return;
}
+ if (isOracleFamilyTypeSource(effectiveDatabaseType.value, row.type)) {
+ void manageTypeDrop(row);
+ return;
+ }
dropTarget.value = row;
dropPreviewSql.value = "";
dropTableCascade.value = false;
@@ -2227,6 +2236,37 @@ function requestDrop(row: ObjectBrowserRow) {
void refreshDropPreviewSql();
}
+async function manageTypeDrop(row: ObjectBrowserRow): Promise<boolean> {
+ const connectionId = props.connection.id;
+ const database = props.database;
+ const owner = row.schema || selectedSchema.value || database;
+ const selectedOwner = selectedSchema.value;
+ const databaseType = effectiveDatabaseType.value as "oracle" | "oceanbase-oracle" | "dameng";
+ try {
+ const outcome = await requestOracleTypeManagement({
+ target: { connectionId, database, owner, name: row.name, databaseType },
+ operation: row.type === "TYPE_BODY" ? "delete-body" : "delete-spec",
+ isCurrent: () => props.connection.id === connectionId && props.database === database && selectedSchema.value === selectedOwner && effectiveDatabaseType.value === databaseType,
+ });
+ if (!outcome.complete) return false;
+ if (props.connection.id === connectionId && props.database === database && selectedSchema.value === selectedOwner) {
+ const removed = rows.value.filter((item) => (item.schema || selectedOwner || database) === owner && item.name === row.name && (item.type === row.type || (row.type === "TYPE" && item.type === "TYPE_BODY")));
+ removePinnedObjectBrowserRows(removed);
+ rows.value = rows.value.filter((item) => !removed.includes(item));
+ if (removed.some((item) => item.id === sourceRow.value?.id)) closeSource();
+ try {
+ await reload();
+ } catch (error) {
+ toast(t("objects.typeManagementRefreshFailed", { message: String(error) }), 5000);
+ }
+ }
+ return true;
+ } catch (error) {
+ toast(t("contextMenu.tableOperationFailed", { message: String(error) }), 5000);
+ return false;
+ }
+}
+
function requestRename(row: ObjectBrowserRow) {
const nextTargetKey = JSON.stringify([props.connection.id, props.database, effectiveDatabaseType.value, row.schema || selectedSchema.value || props.database, row.type, row.name]);
const sameTarget = nextTargetKey === currentViewRenameTargetKey;
@@ -2724,6 +2764,11 @@ async function confirmDrop() {
if (!dropTarget.value) return;
const row = dropTarget.value;
if (row.type === "INDEX") return;
+ if (isOracleFamilyTypeSource(effectiveDatabaseType.value, row.type)) {
+ await manageTypeDrop(row);
+ dropTarget.value = null;
+ return;
+ }
let executedSql = "";
const start = Date.now();
let successRecorded = false;
@@ -2773,6 +2818,8 @@ async function confirmDrop() {
async function buildDropSqlForRow(row: ObjectBrowserRow, options?: { cascade?: boolean }): Promise<string> {
if (row.type === "INDEX") throw new Error(t("schemaIndex.editIndividually"));
+ if (isOracleFamilyTypeSource(effectiveDatabaseType.value, row.type)) throw new Error(t("objects.typeManagementUseSave"));
+ if (row.type === "TYPE" || row.type === "TYPE_BODY") throw new Error(t("objects.sourceReadOnly"));
if (row.type === "TABLE") {
return buildDropTableSql(tableAdminSqlOptions(row, { cascade: options?.cascade && supportsDropTableCascade(effectiveDatabaseType.value) }));
}
@@ -3107,6 +3154,18 @@ function requestBatchDropTables() {
toast(t("schemaIndex.editIndividually"), 4000);
return;
}
+ const selected = [...selectedTableRows.value];
+ const managed = selected.filter((row) => isOracleFamilyTypeSource(effectiveDatabaseType.value, row.type));
+ if (managed.length) {
+ void (async () => {
+ const unique = managed.filter((row) => row.type !== "TYPE_BODY" || !managed.some((other) => other.type === "TYPE" && other.name === row.name && other.schema === row.schema));
+ for (const row of unique) if (!(await manageTypeDrop(row))) return;
+ const remaining = selected.filter((row) => !managed.includes(row));
+ selectedTableIds.value = new Set(remaining.map((row) => row.id));
+ if (remaining.length) requestBatchDropTables();
+ })();
+ return;
+ }
batchDropCascade.value = false;
batchDropProgress.value = { completed: 0, total: 0 };
batchDropPreviewSql.value = "";
@@ -4248,6 +4307,22 @@ async function saveSource() {
if (!sourceIdentity) return;
const identity = sourceIdentity;
assertSourceIdentity(identity);
+ if (isOracleFamilyTypeSource(databaseType, row.type)) {
+ const source = sourceDraft.value;
+ const result = await requestOracleTypeManagement({
+ target: { connectionId, database, owner: schema, name: row.name, databaseType: databaseType as "oracle" | "oceanbase-oracle" | "dameng" },
+ operation: row.type === "TYPE_BODY" ? "save-body" : "save-spec",
+ source,
+ baseSource: sourceEditableText.value,
+ isCurrent: () => sidePanelGuard.isFresh(epoch) && sourceRow.value === row && sourceDraft.value === source,
+ });
+ if (!result.complete || sidePanelGuard.isStale(epoch)) return;
+ toast(t("objects.sourceSaved"));
+ sourceEditing.value = false;
+ sourceDraft.value = "";
+ await loadSourcePanel(row);
+ return;
+ }
const statements = await buildExecutableObjectSourceStatements({
databaseType,
objectType: row.type as ObjectSourceKind,
@@ -5048,12 +5123,16 @@ function getPackageMenuItems(item: ObjectBrowserRow): ContextMenuItem[] {
function getTypeMenuItems(item: ObjectBrowserRow): ContextMenuItem[] {
const items: ContextMenuItem[] = [];
const capabilities = customTypeCapabilities(effectiveDatabaseType.value);
- // Verified PG-family types open the read-only details panel; Xugu keeps its
- // “view source” entry for TYPE/TYPE_BODY rows.
+ // Oracle-family types expose source alongside read-only TYPE details; Xugu
+ // keeps its source entry for TYPE/TYPE_BODY rows.
if (supportsTypeObjectSource(effectiveDatabaseType.value)) {
items.push({ label: t("contextMenu.viewSource"), action: () => openSource(item), icon: Code2 });
}
- if (capabilities.details) {
+ if (supportsOracleFamilyTypeManagement(effectiveDatabaseType.value)) {
+ items.push({ label: t("contextMenu.editObject"), action: () => openSourceTab(item), icon: PencilLine });
+ items.push({ label: t("contextMenu.dropObject"), action: () => requestDrop(item), icon: Trash2, variant: "destructive" });
+ }
+ if (capabilities.details && item.type === "TYPE") {
items.push({ label: t("contextMenu.viewDetails"), action: () => void openTypeInfo(item), icon: Info });
if (capabilities.ddl) {
items.push({ label: t("contextMenu.viewDdl"), action: () => openTypeDdl(item), icon: FileCode });
@@ -5865,7 +5944,7 @@ function getObjectBrowserMenuItems(item: ObjectBrowserRow): ContextMenuItem[] {
</template>
<!-- Type info mode (read-only user-defined type details) -->
<template v-else-if="sidePanelMode === 'type-info'">
- <CustomTypeInfoPanel ref="sidePanelRef" :connection="props.connection" :database="props.database" :schema="sidePanelRow?.schema || selectedSchema || props.database" :name="sidePanelRow?.name || ''" :catalog="props.catalog" @close="closeSidePanel" />
+ <CustomTypeInfoPanel ref="sidePanelRef" :connection="props.connection" :database="props.database" :database-type="effectiveDatabaseType" :schema="sidePanelRow?.schema || selectedSchema || props.database" :name="sidePanelRow?.name || ''" :catalog="props.catalog" @close="closeSidePanel" />
</template>
<template v-else-if="sidePanelMode === 'event-editor'">
<MySqlEventEditor :key="eventEditorKey" :connection="props.connection" :database="props.database" :schema="sidePanelRow?.schema || selectedSchema || props.database" :name="sidePanelRow?.name" :read-only="props.initialEventReadOnly" @saved="onEventSaved" @close="closeSidePanel" />
diff --git a/apps/desktop/src/components/objects/ObjectSourceDialog.vue b/apps/desktop/src/components/objects/ObjectSourceDialog.vue
index a222ff6de0..71426bfd33 100644
--- a/apps/desktop/src/components/objects/ObjectSourceDialog.vue
+++ b/apps/desktop/src/components/objects/ObjectSourceDialog.vue
@@ -12,6 +12,8 @@ import { loadObjectSourceWithRoutineFallback } from "@/lib/table/objectSourceLoa
import { assertSourceIdentity, beginSourceSave, captureSourceIdentity, renewSourceIdentity, type SourceIdentitySnapshot } from "@/lib/table/objectSourceIdentity";
import { jdbcRoutineMetadata, xuguRoutineMetadataFromDefinition, type RoutineMetadata } from "@/lib/table/routineParameters";
import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
+import { isOracleFamilyTypeSource } from "@/lib/database/databaseObjectCapabilities";
+import { requestOracleTypeManagement } from "@/lib/table/oracleTypeManagementRequest";
import * as api from "@/lib/backend/api";
import QueryEditor from "@/components/editor/QueryEditor.vue";
import RoutineMetadataPanel from "@/components/objects/RoutineMetadataPanel.vue";
@@ -87,6 +89,7 @@ onBeforeUnmount(() => {
});
const canEdit = computed(() => sourceEditable.value && (props.objectType !== "SEQUENCE" || props.databaseType === "oceanbase-oracle"));
+const managedType = computed(() => isOracleFamilyTypeSource(props.databaseType, resolvedObjectType.value));
const isViewLike = computed(() => props.objectType === "VIEW" || props.objectType === "MATERIALIZED_VIEW");
const editLabel = computed(() => (isViewLike.value ? t("contextMenu.editView") : t("contextMenu.editObject")));
const title = computed(() => `${editing.value ? editLabel.value : t("contextMenu.viewSource")} - ${props.name}`);
@@ -215,6 +218,21 @@ async function saveSource() {
if (!sourceIdentity) return;
const identity = sourceIdentity;
assertSourceIdentity(identity);
+ if (isOracleFamilyTypeSource(databaseType, objectType)) {
+ const source = draft.value;
+ const result = await requestOracleTypeManagement({
+ target: { connectionId, database, owner: schema, name, databaseType: databaseType as "oracle" | "oceanbase-oracle" | "dameng" },
+ operation: objectType === "TYPE_BODY" ? "save-body" : "save-spec",
+ source,
+ baseSource: editableText.value,
+ isCurrent: () => serial === loadSerial && props.open && draft.value === source,
+ });
+ if (!result.complete || serial !== loadSerial) return;
+ toast(t("objects.sourceSaved"));
+ emit("saved");
+ await loadSource(false);
+ return;
+ }
const statements = await buildExecutableObjectSourceStatements({
databaseType,
objectType,
@@ -341,7 +359,7 @@ function closeDialog() {
</Button>
<Button v-if="editing && section === 'source'" :disabled="saving || !draft.trim()" @click="saveSource">
<Loader2 v-if="saving" class="h-4 w-4 animate-spin" />
- {{ t("objects.saveSource") }}
+ {{ t(managedType ? "objects.typeManagementPreviewSave" : "objects.saveSource") }}
</Button>
</DialogFooter>
</DialogContent>
diff --git a/apps/desktop/src/components/objects/OracleRoutineRenamePreview.vue b/apps/desktop/src/components/objects/OracleRoutineRenamePreview.vue
index 6a60798ecc..0220d33d5f 100644
--- a/apps/desktop/src/components/objects/OracleRoutineRenamePreview.vue
+++ b/apps/desktop/src/components/objects/OracleRoutineRenamePreview.vue
@@ -1,13 +1,12 @@
<script setup lang="ts">
import { computed } from "vue";
import { useI18n } from "vue-i18n";
-import { Button } from "@/components/ui/button";
+import SourceMigrationPreview from "@/components/objects/SourceMigrationPreview.vue";
import type { OracleRoutineRenamePlan } from "@/lib/table/oracleRoutineRename";
const props = defineProps<{ plan: OracleRoutineRenamePlan | null; drafts: Record<string, string>; loading: boolean; validating: boolean; executing: boolean }>();
const emit = defineEmits<{ edit: [key: string, source: string]; validate: []; reload: [] }>();
const { t } = useI18n();
-const busy = computed(() => props.loading || props.validating || props.executing);
const entries = computed(() => {
const plan = props.plan;
if (!plan) return [];
@@ -15,23 +14,27 @@ const entries = computed(() => {
return [
...root,
...plan.callers.map((caller) => ({ key: `${caller.objectType}:${caller.name}`, name: caller.name, objectType: caller.objectType, source: caller.source, draft: caller.draft, generated: caller.rewriteRequired ? caller.rewrittenSource : "", rewriteRequired: caller.rewriteRequired })),
- ];
+ ].map((entry) => ({ ...entry, owner: plan.target.schema, editable: !!entry.source.trim() }));
});
-const assignedIssues = computed(() => new Set(entries.value.map((entry) => entry.name)));
-const statementsCurrent = computed(() => !!props.plan && entries.value.every((entry) => isCurrentDraft(entry.key, entry.draft)));
-function isCurrentDraft(key: string, validatedDraft: string) {
- return (props.drafts[key] ?? validatedDraft) === validatedDraft;
-}
-function edit(key: string, event: Event) {
- emit("edit", key, (event.target as HTMLTextAreaElement).value);
-}
+const issues = computed(() => (props.plan?.issues ?? []).map((issue) => ({ ...issue, objectKey: entries.value.find((entry) => entry.name === issue.objectName)?.key, label: issue.objectName || props.plan?.target.oldName })));
</script>
<template>
- <section class="space-y-3 text-sm" :aria-busy="busy">
+ <SourceMigrationPreview
+ :entries="entries"
+ :issues="issues"
+ :drafts="drafts"
+ :statements="plan?.statements ?? []"
+ :loading="loading"
+ :validating="validating"
+ :executing="executing"
+ :executable="!!plan?.executable"
+ :ready="!!plan"
+ @edit="(key, source) => emit('edit', key, source)"
+ @validate="emit('validate')"
+ @reload="emit('reload')"
+ >
<p class="text-xs leading-relaxed text-muted-foreground">{{ t("objects.routineRenameCoverage") }}</p>
- <p v-if="loading || validating" role="status" class="text-muted-foreground">{{ t("common.loading") }}</p>
- <p v-else-if="!plan?.executable" role="status" class="text-destructive">{{ t("objects.viewRenameValidationPending") }}</p>
<div v-if="plan?.root" class="rounded border border-border p-3">
<p class="mb-2 font-medium">{{ t("objects.routineRenameObjects") }}</p>
<ul class="space-y-1 text-xs text-muted-foreground">
@@ -39,59 +42,5 @@ function edit(key: string, event: Event) {
<li v-for="caller in plan.callers" :key="`${caller.objectType}:${caller.name}`">{{ caller.objectType }} · {{ plan.target.schema }}.{{ caller.name }} · {{ t(caller.rewriteRequired ? "objects.routineRenameRewrite" : "objects.routineRenameCompile") }}</li>
</ul>
</div>
- <ul v-if="plan?.issues.some((issue) => !issue.objectName || !assignedIssues.has(issue.objectName))" class="space-y-2" aria-live="polite">
- <li v-for="(issue, index) in plan.issues.filter((item) => !item.objectName || !assignedIssues.has(item.objectName))" :key="index" class="rounded border border-destructive/40 p-2">
- <p class="font-medium text-destructive">{{ issue.objectName || plan.target.oldName }} · {{ t("objects.viewRenameNeedsRepair") }}</p>
- <p v-if="!issue.repairable" class="text-xs text-destructive">{{ t("objects.viewRenameMetadataProblem") }}</p>
- <details class="mt-1 text-xs text-muted-foreground" data-diagnostics>
- <summary class="cursor-pointer">{{ t("objects.viewRenameDiagnostics") }}</summary>
- <pre class="mt-1 whitespace-pre-wrap break-all">{{ issue.message }}</pre>
- </details>
- </li>
- </ul>
- <details v-for="entry in entries" :key="entry.key" :open="plan?.issues.some((issue) => issue.objectName === entry.name)" class="rounded border border-border" :data-source-name="entry.key">
- <summary class="flex cursor-pointer items-center justify-between gap-3 px-3 py-2 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring">
- <span class="min-w-0 break-all font-medium">{{ entry.objectType }} · {{ entry.name }}</span>
- <span class="shrink-0 rounded bg-muted px-2 py-0.5 text-xs" :class="plan?.issues.some((issue) => issue.objectName === entry.name) ? 'text-destructive' : 'text-muted-foreground'">
- {{ t(plan?.issues.some((issue) => issue.objectName === entry.name) ? "objects.viewRenameNeedsRepair" : "objects.viewRenameDefinitionReady") }}
- </span>
- </summary>
- <div class="space-y-3 border-t border-border p-3">
- <ul v-if="plan?.issues.some((issue) => issue.objectName === entry.name)" class="space-y-2" aria-live="polite">
- <li v-for="(issue, index) in plan.issues.filter((item) => item.objectName === entry.name)" :key="index" class="space-y-1">
- <p class="font-medium text-destructive">{{ entry.name }} · {{ t("objects.viewRenameNeedsRepair") }}</p>
- <p v-if="!issue.repairable" class="text-xs text-destructive">{{ t("objects.viewRenameMetadataProblem") }}</p>
- <details class="text-xs text-muted-foreground" data-diagnostics>
- <summary class="cursor-pointer">{{ t("objects.viewRenameDiagnostics") }}</summary>
- <pre class="mt-1 whitespace-pre-wrap break-all">{{ issue.message }}</pre>
- </details>
- </li>
- </ul>
- <label v-if="entry.rewriteRequired" class="block space-y-1">
- <span class="block text-xs text-muted-foreground">{{ t("objects.viewRenameDraft") }} · {{ plan?.target.schema }}.{{ entry.name }}</span>
- <textarea
- :value="drafts[entry.key] ?? entry.draft"
- :disabled="busy || !entry.source.trim()"
- spellcheck="false"
- rows="10"
- class="w-full resize-y rounded border border-input bg-background p-2 font-mono text-xs leading-relaxed focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50"
- :data-source-draft="entry.key"
- @input="edit(entry.key, $event)"
- />
- </label>
- <div v-if="entry.generated && isCurrentDraft(entry.key, entry.draft)" class="space-y-1">
- <p class="text-xs text-muted-foreground">{{ t("objects.viewRenameFinalSql") }}</p>
- <pre class="max-h-48 overflow-auto whitespace-pre-wrap break-all rounded bg-muted p-2 font-mono text-xs">{{ entry.generated }}</pre>
- </div>
- </div>
- </details>
- <details v-if="statementsCurrent && plan?.statements.length" class="rounded border border-border" open>
- <summary class="cursor-pointer px-3 py-2 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring">{{ t("objects.viewRenameFinalSql") }}</summary>
- <pre class="max-h-64 overflow-auto whitespace-pre-wrap break-all border-t border-border p-3 font-mono text-xs">{{ plan.statements.join("\n\n") }}</pre>
- </details>
- <div class="flex flex-wrap gap-2">
- <Button type="button" variant="outline" size="sm" :disabled="busy || !plan" data-validate @click="emit('validate')">{{ t("objects.viewRenameValidate") }}</Button>
- <Button type="button" variant="outline" size="sm" :disabled="busy" data-reload @click="emit('reload')">{{ t("objects.viewRenameReload") }}</Button>
- </div>
- </section>
+ </SourceMigrationPreview>
</template>
diff --git a/apps/desktop/src/components/objects/OracleTypeDataMappingPanel.vue b/apps/desktop/src/components/objects/OracleTypeDataMappingPanel.vue
new file mode 100644
index 0000000000..3729df8b4f
--- /dev/null
+++ b/apps/desktop/src/components/objects/OracleTypeDataMappingPanel.vue
@@ -0,0 +1,273 @@
+<script setup lang="ts">
+import { computed, nextTick, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import * as api from "@/lib/backend/api";
+import { uuid } from "@/lib/common/utils";
+import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
+import { executeOracleTypeDataInsert, prepareOracleTypeDataInsert, verifyOracleTypeDataMappings } from "@/lib/table/oracleTypeDataMapping";
+import { registerOracleTypeDataMapping, type OracleTypeManagementDraft } from "@/lib/table/oracleTypeManagement";
+import type { OracleTypeDataMappingInput, OracleTypeDataRelationKey } from "@/types/database";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useQueryStore } from "@/stores/queryStore";
+
+const props = defineProps<{ plan: OracleTypeManagementDraft; disabled: boolean; persist: (plan: OracleTypeManagementDraft) => Promise<void>; isCurrent: () => boolean }>();
+const emit = defineEmits<{ update: [plan: OracleTypeManagementDraft]; busy: [busy: boolean] }>();
+const { t } = useI18n();
+const connectionStore = useConnectionStore();
+const queryStore = useQueryStore();
+const working = ref(false);
+let saves: Promise<void> = Promise.resolve();
+let savesPending = 0;
+let previousInsertDrafts: Record<string, string> = {};
+const error = ref("");
+const preparation = ref<OracleTypeDataMappingInput>();
+const targetPaths = ref<string[]>([]);
+const insertDrafts = ref<Record<string, string>>({});
+const sourceIndex = ref(0);
+const clone = <T>(value: T): T => JSON.parse(JSON.stringify(value));
+const sources = computed<OracleTypeDataRelationKey[]>(() => [...new Map(props.plan.originalSnapshot.persistentReferences.map((reference) => [JSON.stringify([reference.owner, reference.tableName]), { owner: reference.owner, name: reference.tableName }])).values()]);
+const availableSources = computed(() => sources.value.filter((source) => !props.plan.dataMappings.some((record) => record.manifest.mapping.source.owner === source.owner && record.manifest.mapping.source.name === source.name)));
+const locked = computed(() => props.disabled || working.value);
+const quote = (name: string) => `"${name.replaceAll('"', '""')}"`;
+const label = (key: OracleTypeDataRelationKey) => `${quote(key.owner)}.${quote(key.name)}`;
+
+watch(
+ () => props.plan,
+ (plan) => {
+ if (preparation.value?.id !== plan.dataPreparation?.id) {
+ preparation.value = plan.dataPreparation && clone(plan.dataPreparation);
+ targetPaths.value = plan.dataTargetPaths ? [...plan.dataTargetPaths] : (preparation.value?.fields.map((field) => JSON.stringify(field.targetPath)) ?? []);
+ }
+ const incoming = Object.fromEntries(plan.dataMappings.map((record) => [record.manifest.mapping.id, record.insertDraft ?? record.insertSql]));
+ for (const [id, text] of Object.entries(incoming)) if (insertDrafts.value[id] === undefined || insertDrafts.value[id] === previousInsertDrafts[id]) insertDrafts.value[id] = text;
+ previousInsertDrafts = incoming;
+ },
+ { immediate: true },
+);
+
+async function run(action: () => Promise<void>) {
+ if (locked.value) return;
+ working.value = true;
+ emit("busy", true);
+ error.value = "";
+ try {
+ await saves;
+ await nextTick();
+ await action();
+ } catch (cause) {
+ error.value = cause instanceof Error ? cause.message : String(cause);
+ } finally {
+ working.value = false;
+ emit("busy", savesPending > 0);
+ }
+}
+async function save(plan: OracleTypeManagementDraft) {
+ await props.persist(plan);
+ emit("update", plan);
+}
+function queueSave(action: () => Promise<void>) {
+ savesPending++;
+ emit("busy", true);
+ saves = saves
+ .then(async () => {
+ await nextTick();
+ await action();
+ })
+ .catch((cause) => {
+ error.value = cause instanceof Error ? cause.message : String(cause);
+ })
+ .finally(() => {
+ savesPending--;
+ emit("busy", working.value || savesPending > 0);
+ });
+ return saves;
+}
+async function savePreparation() {
+ await queueSave(async () => {
+ if (!preparation.value) return;
+ const next = clone(props.plan);
+ next.dataPreparation = clone(preparation.value);
+ next.dataTargetPaths = [...targetPaths.value];
+ next.revision++;
+ next.executable = false;
+ next.requiresReverify = true;
+ await save(next);
+ });
+}
+async function describe() {
+ await run(async () => {
+ const source = availableSources.value[sourceIndex.value];
+ if (!source) return;
+ const result = await api.verifyOracleTypeData({ target: props.plan.target, action: "describe", relation: source });
+ if (!result.relation) throw new Error("The complete source projection could not be read.");
+ const next = clone(props.plan);
+ next.dataPreparation = {
+ id: uuid(),
+ source,
+ old: { owner: source.owner, name: "" },
+ expected: { owner: source.owner, name: "" },
+ target: { ...source },
+ fields: result.relation.projection.map((field, index) => ({ sourcePath: field.path, objectNull: field.objectNull, oldColumn: `C${index + 1}`, expectedColumn: `C${index + 1}`, targetPath: [...field.path], targetObjectNull: field.objectNull, unchanged: true })),
+ };
+ next.dataTargetPaths = undefined;
+ next.revision++;
+ await save(next);
+ });
+}
+async function register() {
+ await run(async () => {
+ const value = preparation.value;
+ if (!value) return;
+ const mapping = clone(value);
+ mapping.fields.forEach((field, index) => {
+ const path: unknown = JSON.parse(targetPaths.value[index]);
+ if (!Array.isArray(path) || !path.length || path.some((part) => typeof part !== "string" || !part)) throw new Error(t("objects.typeDataPathError"));
+ field.targetPath = path;
+ });
+ const next = await registerOracleTypeDataMapping(props.plan, mapping, props.persist);
+ emit("update", next);
+ });
+}
+function openPreparationSql() {
+ const value = preparation.value;
+ if (!value) return;
+ const fields = value.fields
+ .map((field) => {
+ const path = `T.${field.sourcePath.map(quote).join(".")}`;
+ return ` ${field.objectNull ? `CASE WHEN ${path} IS NULL THEN 1 ELSE 0 END` : path} AS ${quote(field.oldColumn)}`;
+ })
+ .join(",\n");
+ queryStore.createTab(props.plan.target.connectionId, props.plan.target.database, t("objects.typeDataPrepareSql"), "query", value.source.owner, `SELECT\n${fields}\nFROM ${label(value.source)} T;`, undefined, { forceNew: true });
+}
+async function saveInsertDraft(id: string) {
+ await queueSave(async () => {
+ const next = clone(props.plan);
+ const record = next.dataMappings.find((record) => record.manifest.mapping.id === id);
+ if (!record || !["not-sent", "failed"].includes(record.insertState)) return;
+ record.insertDraft = insertDrafts.value[id];
+ record.insertSql = "";
+ next.executable = false;
+ next.requiresReverify = true;
+ next.revision++;
+ await save(next);
+ });
+}
+async function previewInsert(id: string) {
+ await run(async () => emit("update", await prepareOracleTypeDataInsert(props.plan, id, insertDrafts.value[id] ?? "", props.persist)));
+}
+async function insert(id: string) {
+ await run(async () => {
+ const record = props.plan.dataMappings.find((record) => record.manifest.mapping.id === id);
+ if (!record || insertDrafts.value[id] !== record.insertSql) return;
+ await executeWithProductionSqlGuard({
+ connection: connectionStore.getConfig(props.plan.target.connectionId),
+ database: props.plan.target.database,
+ sql: record.insertSql,
+ source: t("objects.typeDataTitle"),
+ execute: async () => {
+ if (!props.isCurrent()) return false;
+ await executeOracleTypeDataInsert(props.plan, id, { persist: props.persist, isCurrent: props.isCurrent });
+ return true;
+ },
+ });
+ emit("update", clone(props.plan));
+ });
+}
+async function verify() {
+ await run(async () => {
+ const next = clone(props.plan);
+ await verifyOracleTypeDataMappings(next);
+ next.revision++;
+ next.executable = false;
+ next.requiresReverify = true;
+ await save(next);
+ });
+}
+</script>
+
+<template>
+ <section class="space-y-3 border-t pt-4" aria-labelledby="type-data-title">
+ <h3 id="type-data-title" class="text-sm font-semibold">{{ t("objects.typeDataTitle") }}</h3>
+ <p class="text-sm leading-relaxed text-muted-foreground">{{ t("objects.typeDataInstructions") }}</p>
+ <p v-if="error" role="alert" class="whitespace-pre-wrap break-words text-sm text-destructive">{{ error }}</p>
+ <div v-if="availableSources.length && !preparation" class="flex flex-wrap items-center gap-2">
+ <select v-model="sourceIndex" :disabled="locked" :aria-label="t('objects.typeDataSource')" class="min-w-0 rounded border bg-background p-2 text-sm">
+ <option v-for="(source, index) in availableSources" :key="label(source)" :value="index">{{ label(source) }}</option>
+ </select>
+ <Button variant="outline" size="sm" :disabled="locked" @click="describe">{{ t("objects.typeDataReadProjection") }}</Button>
+ </div>
+ <div v-if="preparation" class="space-y-3 rounded border p-3">
+ <p class="break-words font-mono text-sm">{{ label(preparation.source) }}</p>
+ <div class="grid gap-3 sm:grid-cols-3">
+ <fieldset v-for="kind in ['old', 'expected', 'target'] as const" :key="kind" class="space-y-2" :disabled="locked">
+ <legend class="mb-1 text-sm font-medium">{{ kind === "old" ? "OLD" : kind === "expected" ? "EXPECTED" : t("objects.typeDataTarget") }}</legend>
+ <label class="block space-y-1 text-xs">{{ t("objects.typeDataOwner") }}<Input v-model="preparation[kind].owner" @change="savePreparation" /></label>
+ <label class="block space-y-1 text-xs">{{ t("objects.name") }}<Input v-model="preparation[kind].name" @change="savePreparation" /></label>
+ </fieldset>
+ </div>
+ <div class="overflow-x-auto">
+ <table class="w-full text-left text-sm">
+ <thead>
+ <tr class="border-b">
+ <th class="p-2">{{ t("objects.typeDataSource") }}</th>
+ <th class="p-2">OLD</th>
+ <th class="p-2">EXPECTED</th>
+ <th class="p-2">{{ t("objects.typeDataTargetPath") }}</th>
+ <th class="p-2">{{ t("objects.typeDataUnchanged") }}</th>
+ </tr>
+ </thead>
+ <tbody>
+ <tr v-for="(field, index) in preparation.fields" :key="index" class="border-b last:border-0">
+ <td class="p-2 font-mono text-xs">{{ JSON.stringify(field.sourcePath) }}{{ field.objectNull ? " IS NULL" : "" }}</td>
+ <td class="min-w-28 p-2"><Input v-model="field.oldColumn" :disabled="locked" :aria-label="`OLD ${index + 1}`" @change="savePreparation" /></td>
+ <td class="min-w-28 p-2"><Input v-model="field.expectedColumn" :disabled="locked" :aria-label="`EXPECTED ${index + 1}`" @change="savePreparation" /></td>
+ <td class="min-w-40 space-y-1 p-2">
+ <Input v-model="targetPaths[index]" :disabled="locked" :aria-label="`${t('objects.typeDataTargetPath')} ${index + 1}`" @change="savePreparation" /><label class="flex items-center gap-1 font-mono text-xs"
+ ><input v-model="field.targetObjectNull" type="checkbox" :disabled="locked" :aria-label="`${t('objects.typeDataTargetPath')} ${index + 1} IS NULL`" @change="savePreparation" />IS NULL</label
+ >
+ </td>
+ <td class="p-2"><input v-model="field.unchanged" type="checkbox" :disabled="locked" :aria-label="`${t('objects.typeDataUnchanged')} ${index + 1}`" @change="savePreparation" /></td>
+ </tr>
+ </tbody>
+ </table>
+ </div>
+ <p class="text-sm text-muted-foreground">{{ t("objects.typeDataPrepareHint") }}</p>
+ <div class="flex flex-wrap gap-2">
+ <Button variant="outline" size="sm" :disabled="locked" @click="openPreparationSql">{{ t("objects.typeDataPrepareSql") }}</Button
+ ><Button variant="outline" size="sm" :disabled="locked" @click="register">{{ t("objects.typeDataRegister") }}</Button>
+ </div>
+ </div>
+ <div v-for="record in plan.dataMappings" :key="record.manifest.mapping.id" class="space-y-3 rounded border p-3">
+ <p class="break-words text-sm font-medium">{{ label(record.manifest.mapping.source) }} → {{ label(record.manifest.mapping.target) }}</p>
+ <p class="break-words font-mono text-xs">OLD {{ label(record.manifest.mapping.old) }} · {{ record.manifest.old.rowCount }}<br />EXPECTED {{ label(record.manifest.mapping.expected) }} · {{ record.manifest.expected.rowCount }}</p>
+ <p role="status" class="text-sm">{{ record.manifest.verifiedTarget ? t("objects.typeDataVerified") : t("objects.typeDataWaiting") }}</p>
+ <details>
+ <summary class="cursor-pointer text-sm text-muted-foreground">{{ t("objects.typeDataIntegrity") }}</summary>
+ <pre class="mt-2 overflow-x-auto whitespace-pre-wrap break-all text-xs">{{
+ JSON.stringify({ oldId: record.manifest.old.relation.objectId, old: record.manifest.old.fingerprint, expectedId: record.manifest.expected.relation.objectId, expected: record.manifest.expected.fingerprint }, null, 2)
+ }}</pre>
+ </details>
+ <details v-if="!record.manifest.verifiedTarget" class="space-y-2">
+ <summary class="cursor-pointer text-sm">{{ t("objects.typeDataBoundedInsert") }}</summary>
+ <p class="text-sm text-muted-foreground">{{ t("objects.typeDataInsertHint") }}</p>
+ <textarea
+ v-model="insertDrafts[record.manifest.mapping.id]"
+ class="min-h-24 w-full resize-y rounded border border-input bg-background p-2 font-mono text-xs leading-relaxed focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+ spellcheck="false"
+ :disabled="locked || !['not-sent', 'failed'].includes(record.insertState)"
+ :aria-label="t('objects.typeDataBoundedInsert')"
+ @change="saveInsertDraft(record.manifest.mapping.id)"
+ />
+ <p role="status" class="text-sm">{{ t(`objects.typeManagementState.${record.insertState}`) }}{{ record.message ? ` · ${record.message}` : "" }}</p>
+ <div class="flex flex-wrap gap-2">
+ <Button variant="outline" size="sm" :disabled="locked || !['not-sent', 'failed'].includes(record.insertState)" @click="previewInsert(record.manifest.mapping.id)">{{ t("objects.typeDataPreviewInsert") }}</Button
+ ><Button variant="outline" size="sm" :disabled="locked || record.insertState !== 'not-sent' || !record.insertSql || record.insertSql !== insertDrafts[record.manifest.mapping.id]" @click="insert(record.manifest.mapping.id)">{{ t("objects.typeDataRunInsert") }}</Button>
+ </div>
+ </details>
+ </div>
+ <Button v-if="plan.dataMappings.length" variant="outline" size="sm" :disabled="locked" @click="verify">{{ t("objects.typeDataVerify") }}</Button>
+ <p v-if="plan.dataMappings.length" class="text-sm text-muted-foreground">{{ t("objects.typeDataKeepBaselines") }}</p>
+ </section>
+</template>
diff --git a/apps/desktop/src/components/objects/OracleTypeManagementDialog.vue b/apps/desktop/src/components/objects/OracleTypeManagementDialog.vue
new file mode 100644
index 0000000000..f200c095c8
--- /dev/null
+++ b/apps/desktop/src/components/objects/OracleTypeManagementDialog.vue
@@ -0,0 +1,352 @@
+<script setup lang="ts">
+import { computed, nextTick, onBeforeUnmount, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { Loader2 } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import SourceMigrationPreview, { type SourceMigrationEntry } from "@/components/objects/SourceMigrationPreview.vue";
+import OracleTypeDataMappingPanel from "@/components/objects/OracleTypeDataMappingPanel.vue";
+import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
+import { executeOracleTypeManagement, OracleTypeManagementFailure, prepareOracleTypeManagement, typeManagementObjectKey, type OracleTypeManagementDraft, type TypeManagementObjectDraft } from "@/lib/table/oracleTypeManagement";
+import { finishOracleTypeManagementRequest, oracleTypeManagementRequest, type TypeManagementRequest } from "@/lib/table/oracleTypeManagementRequest";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useQueryStore } from "@/stores/queryStore";
+import { useToast } from "@/composables/useToast";
+import * as api from "@/lib/backend/api";
+
+const { t } = useI18n();
+const { toast } = useToast();
+const queryStore = useQueryStore();
+const connectionStore = useConnectionStore();
+const plan = ref<OracleTypeManagementDraft | null>(null);
+const drafts = ref<Record<string, string>>({});
+const tabId = ref("");
+const loading = ref(false);
+const executing = ref(false);
+const dataBusy = ref(false);
+const error = ref("");
+const notice = ref("");
+const errorRef = ref<HTMLElement | null>(null);
+let request: TypeManagementRequest | null = null;
+let tabSqlAtOpen = "";
+let serial = 0;
+const stopRequested = ref(false);
+const maintenanceConfirmed = ref(false);
+const busy = computed(() => loading.value || executing.value || dataBusy.value);
+const deleting = computed(() => plan.value?.operation.startsWith("delete") ?? request?.operation.startsWith("delete"));
+const statements = computed(() => (plan.value?.requiresReverify ? [] : (plan.value?.steps.filter((step) => step.state !== "confirmed").map((step) => step.sql) ?? [])));
+const maintenanceRequired = computed(() => !!plan.value && (plan.value.steps.some((step) => step.kind === "drop-dependent") || (!plan.value.operation.endsWith("body") && plan.value.originalSnapshot.persistentReferences.length > 0)));
+const entries = computed<SourceMigrationEntry[]>(
+ () =>
+ plan.value?.drafts.map((draft) => {
+ const key = typeManagementObjectKey(draft);
+ const root = draft.owner === plan.value!.target.owner && draft.name === plan.value!.target.name;
+ const original = plan.value!.originalSnapshot.objects.find((object) => typeManagementObjectKey(object) === key);
+ return {
+ key,
+ owner: draft.owner,
+ name: draft.name,
+ objectType: draft.objectType === "TRIGGER" ? `${draft.objectType} · ${original?.triggerEnabled === true ? "ENABLED" : original?.triggerEnabled === false ? "DISABLED" : t("common.unknown")}` : draft.objectType,
+ source: original?.source ?? "",
+ currentSource: (plan.value!.observedSnapshot ?? plan.value!.lastSnapshot).objects.find((object) => typeManagementObjectKey(object) === key)?.source ?? undefined,
+ draft: draft.source,
+ generated: plan.value!.requiresReverify
+ ? ""
+ : plan
+ .value!.steps.filter((step) => typeManagementObjectKey(step.object) === key && step.state !== "confirmed")
+ .map((step) => step.sql)
+ .join("\n\n"),
+ rewriteRequired: !(deleting.value && root),
+ showOriginal: true,
+ };
+ }) ?? [],
+);
+const issues = computed(() => {
+ const visible = [...(plan.value?.issues ?? [])];
+ for (const step of plan.value?.steps ?? [])
+ if (["failed", "unknown"].includes(step.state) && !visible.some((issue) => issue.objectKey === typeManagementObjectKey(step.object))) visible.push({ code: "write-result", objectKey: typeManagementObjectKey(step.object), message: step.message ?? step.state, repairable: true });
+ return visible.map((issue) => {
+ const object = plan.value?.originalSnapshot.objects.find((object) => typeManagementObjectKey(object) === issue.objectKey);
+ return { ...issue, label: object ? `${object.objectType} · ${object.owner}.${object.name}` : undefined };
+ });
+});
+
+watch(
+ () => oracleTypeManagementRequest.value?.id,
+ async () => {
+ const current = oracleTypeManagementRequest.value;
+ if (!current) return;
+ request = current;
+ const epoch = ++serial;
+ loading.value = true;
+ plan.value = null;
+ drafts.value = {};
+ error.value = "";
+ notice.value = "";
+ tabId.value = "";
+ stopRequested.value = false;
+ maintenanceConfirmed.value = false;
+ try {
+ const target = current.target;
+ await connectionStore.ensureConnected(target.connectionId);
+ if (epoch !== serial) return;
+ const existing = current.tabId
+ ? queryStore.tabs.find((tab) => tab.id === current.tabId)
+ : queryStore.tabs.find((tab) => {
+ const pending = tab.typeManagementDraft;
+ return pending && pending.state !== "complete" && pending.target.connectionId === target.connectionId && pending.target.database === target.database && pending.target.owner === target.owner && pending.target.name === target.name;
+ });
+ const previous = existing?.typeManagementDraft?.state !== "complete" ? existing?.typeManagementDraft : undefined;
+ const operation = previous?.operation ?? current.operation;
+ if (previous) notice.value = t("objects.typeManagementExistingDraft");
+ const values = previous?.drafts.map((draft) => ({ ...draft })) ?? [];
+ const kind = operation.endsWith("body") ? "TYPE BODY" : "TYPE";
+ if (current.source !== undefined && operation === current.operation && !previous?.steps.some((step) => step.state !== "not-sent")) {
+ const key = { owner: target.owner, name: target.name, objectType: kind };
+ const index = values.findIndex((item) => typeManagementObjectKey(item) === typeManagementObjectKey(key));
+ const value = { ...key, source: current.source };
+ if (index < 0) values.push(value);
+ else values[index] = value;
+ }
+ const prepared = await prepareOracleTypeManagement(target, operation, values, previous);
+ if (current.baseSource !== undefined && operation === current.operation && !operation.startsWith("delete") && !previous?.steps.some((step) => step.state !== "not-sent")) {
+ const baseline = await api.buildOracleTypeManagementSql({ databaseType: target.databaseType, operation: kind === "TYPE BODY" ? "save_body" : "save_spec", owner: target.owner, name: target.name, source: current.baseSource });
+ const original = prepared.originalSnapshot.objects.find((object) => object.owner === target.owner && object.name === target.name && object.objectType === kind);
+ if (!baseline.sourceFingerprint || baseline.sourceFingerprint !== original?.sourceFingerprint) {
+ prepared.issues.push({
+ code: "loaded-source-changed",
+ objectKey: typeManagementObjectKey({ owner: target.owner, name: target.name, objectType: kind }),
+ message: "The TYPE source changed since it was loaded. Review the live original definition and your draft, then revalidate.",
+ repairable: true,
+ });
+ prepared.executable = false;
+ prepared.state = "draft";
+ }
+ }
+ if (epoch !== serial) return;
+ plan.value = prepared;
+ drafts.value = Object.fromEntries(prepared.drafts.map((draft) => [typeManagementObjectKey(draft), draft.source]));
+ if (existing) tabId.value = existing.id;
+ else {
+ const selected = prepared.drafts.find((draft) => draft.owner === target.owner && draft.name === target.name && draft.objectType === kind);
+ const original = prepared.originalSnapshot.objects.find((object) => object.owner === target.owner && object.name === target.name && object.objectType === kind);
+ tabId.value = queryStore.createTab(target.connectionId, target.database, `${kind} · ${target.name}`, "query", target.owner, selected?.source ?? original?.source ?? "", undefined, { forceNew: true, sourceView: true });
+ queryStore.setObjectSource(tabId.value, { schema: target.owner, name: target.name, objectType: kind === "TYPE BODY" ? "TYPE_BODY" : "TYPE" });
+ }
+ tabSqlAtOpen = queryStore.tabs.find((tab) => tab.id === tabId.value)?.sql ?? "";
+ await persist(prepared);
+ } catch (cause) {
+ if (epoch === serial) {
+ error.value = cause instanceof Error ? cause.message : String(cause);
+ if (plan.value) plan.value.executable = false;
+ }
+ } finally {
+ if (epoch === serial) loading.value = false;
+ }
+ },
+ { immediate: true },
+);
+
+function currentDrafts(): TypeManagementObjectDraft[] {
+ return plan.value?.drafts.map((draft) => ({ ...draft, source: drafts.value[typeManagementObjectKey(draft)] ?? draft.source })) ?? [];
+}
+
+function edit(key: string, source: string) {
+ if (!plan.value || busy.value) return;
+ drafts.value[key] = source;
+ plan.value.drafts = currentDrafts();
+ plan.value.executable = false;
+ plan.value.requiresReverify = true;
+ plan.value.state = "draft";
+ plan.value.revision++;
+ maintenanceConfirmed.value = false;
+ const tab = queryStore.tabs.find((tab) => tab.id === tabId.value);
+ if (tab) tab.typeManagementDraft = JSON.parse(JSON.stringify({ ...plan.value, drafts: currentDrafts() }));
+}
+
+async function persist(record: OracleTypeManagementDraft) {
+ await queryStore.persistTypeManagementDraft(tabId.value, record);
+}
+
+function isRequestCurrent() {
+ const pending = request;
+ return !!pending && oracleTypeManagementRequest.value?.id === pending.id && pending.isCurrent?.() !== false;
+}
+
+async function revalidate() {
+ if (!plan.value || busy.value) return;
+ const previous = plan.value;
+ const epoch = serial;
+ loading.value = true;
+ error.value = "";
+ maintenanceConfirmed.value = false;
+ try {
+ const next = await prepareOracleTypeManagement(previous.target, previous.operation, currentDrafts(), previous);
+ if (epoch !== serial) return;
+ plan.value = next;
+ drafts.value = Object.fromEntries(next.drafts.map((draft) => [typeManagementObjectKey(draft), draft.source]));
+ await persist(next);
+ if (next.state === "complete" && request) await completePlan(next, request);
+ } catch (cause) {
+ if (epoch === serial) {
+ error.value = cause instanceof Error ? cause.message : String(cause);
+ if (plan.value) plan.value.executable = false;
+ }
+ } finally {
+ if (epoch === serial) loading.value = false;
+ }
+}
+
+async function execute() {
+ const approved = plan.value;
+ const pending = request;
+ if (!approved?.executable || !pending || busy.value || (maintenanceRequired.value && !maintenanceConfirmed.value)) return;
+ const approvedDrafts = JSON.stringify(currentDrafts());
+ const isCurrent = () => oracleTypeManagementRequest.value?.id === pending.id && pending.isCurrent?.() !== false && JSON.stringify(currentDrafts()) === approvedDrafts;
+ executing.value = true;
+ error.value = "";
+ stopRequested.value = false;
+ try {
+ const completed = await executeWithProductionSqlGuard({
+ connection: connectionStore.getConfig(approved.target.connectionId),
+ database: approved.target.database,
+ sql: statements.value.join("\n\n"),
+ source: t("production.sourceObjectSource"),
+ execute: async () => {
+ if (!isCurrent()) return false;
+ await executeOracleTypeManagement(approved, { persist, isCurrent, shouldStop: () => stopRequested.value });
+ return true;
+ },
+ });
+ if (!completed) return;
+ await completePlan(approved, pending);
+ } catch (cause) {
+ if (cause instanceof OracleTypeManagementFailure) plan.value = cause.plan;
+ error.value = cause instanceof Error ? cause.message : String(cause);
+ await nextTick();
+ errorRef.value?.focus();
+ } finally {
+ executing.value = false;
+ }
+}
+
+async function completePlan(approved: OracleTypeManagementDraft, pending: TypeManagementRequest) {
+ const tab = queryStore.tabs.find((tab) => tab.id === tabId.value);
+ if (tab) {
+ tab.typeSourceEditing = false;
+ const selectedKind = approved.operation.endsWith("body") ? "TYPE BODY" : "TYPE";
+ const saved = approved.drafts.find((draft) => draft.owner === approved.target.owner && draft.name === approved.target.name && draft.objectType === selectedKind);
+ if (!approved.operation.startsWith("delete") && saved && tab.sql === tabSqlAtOpen) {
+ queryStore.updateSql(tab.id, saved.source);
+ queryStore.markTabClean(tab);
+ queryStore.refreshObjectSourceTab(tab.id);
+ }
+ }
+ try {
+ await connectionStore.refreshObjectListTreeNode(approved.target.connectionId, approved.target.database, approved.target.owner);
+ } catch (cause) {
+ toast(t("objects.typeManagementRefreshFailed", { message: cause instanceof Error ? cause.message : String(cause) }), 6000);
+ }
+ finishOracleTypeManagementRequest(pending.id, { complete: approved.operation === pending.operation, target: approved.target, operation: approved.operation, snapshot: approved.lastSnapshot });
+}
+
+function close() {
+ if (executing.value || dataBusy.value || !request) return;
+ ++serial;
+ finishOracleTypeManagementRequest(request.id, { complete: false, target: request.target, operation: request.operation });
+ request = null;
+}
+onBeforeUnmount(() => {
+ stopRequested.value = true;
+ ++serial;
+});
+</script>
+
+<template>
+ <Dialog
+ :open="!!oracleTypeManagementRequest"
+ @update:open="
+ (open) => {
+ if (!open) close();
+ }
+ "
+ >
+ <DialogContent
+ class="max-h-[calc(var(--dbx-viewport-height)-2rem)] grid-rows-[auto_minmax(0,1fr)_auto] sm:max-w-[1000px]"
+ @escape-key-down="
+ (event) => {
+ if (executing || dataBusy) event.preventDefault();
+ }
+ "
+ @pointer-down-outside="
+ (event) => {
+ if (executing || dataBusy) event.preventDefault();
+ }
+ "
+ >
+ <DialogHeader>
+ <DialogTitle>{{ t("objects.typeManagementTitle") }} · {{ plan?.target.owner ?? oracleTypeManagementRequest?.target.owner }}.{{ plan?.target.name ?? oracleTypeManagementRequest?.target.name }}</DialogTitle>
+ </DialogHeader>
+ <div class="min-h-0 space-y-4 overflow-y-auto pr-1">
+ <p class="text-sm leading-relaxed text-muted-foreground">{{ t("objects.typeManagementNonAtomic") }}</p>
+ <p class="text-sm text-muted-foreground">{{ t("objects.typeManagementScope") }}</p>
+ <p v-if="notice" role="status" class="text-sm">{{ notice }}</p>
+ <p v-if="deleting" class="rounded border border-destructive/40 bg-destructive/5 p-3 text-sm">{{ t((plan?.operation ?? oracleTypeManagementRequest?.operation) === "delete-body" ? "objects.typeManagementDeleteBody" : "objects.typeManagementDeleteSpec") }}</p>
+ <p v-if="error" ref="errorRef" role="alert" tabindex="-1" class="whitespace-pre-wrap break-words rounded border border-destructive/40 p-3 text-sm text-destructive focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring">{{ error }}</p>
+ <SourceMigrationPreview
+ :entries="entries"
+ :issues="issues"
+ :drafts="drafts"
+ :statements="statements"
+ :loading="loading"
+ :validating="false"
+ :executing="executing || dataBusy"
+ :executable="!!plan?.executable"
+ :ready="!!plan"
+ :draft-label="t('objects.typeManagementDraftLabel')"
+ :validation-pending-message="t('objects.typeManagementValidationPending')"
+ @edit="edit"
+ @validate="revalidate"
+ @reload="revalidate"
+ />
+ <p v-if="plan?.nativeEvolution" role="status" class="text-sm leading-relaxed text-muted-foreground" data-native-type-evolution>{{ t("objects.typeManagementNativeEvolution") }}</p>
+ <OracleTypeDataMappingPanel
+ v-if="plan && !plan.nativeEvolution && !plan.operation.endsWith('body') && (plan.originalSnapshot.persistentReferences.length || plan.dataMappings.length)"
+ :plan="plan"
+ :disabled="loading || executing"
+ :persist="persist"
+ :is-current="isRequestCurrent"
+ @update="plan = $event"
+ @busy="dataBusy = $event"
+ />
+ <label v-if="maintenanceRequired" class="flex items-start gap-2 rounded border border-border p-3 text-sm leading-relaxed">
+ <input v-model="maintenanceConfirmed" type="checkbox" :disabled="busy" class="mt-1 h-4 w-4 shrink-0 accent-primary" />
+ <span>{{ t("objects.typeManagementMaintenance") }}</span>
+ </label>
+ <ol v-if="plan?.steps.some((step) => step.state !== 'not-sent')" class="space-y-2 border-t border-border pt-3 text-sm" aria-live="polite" data-type-execution-record>
+ <li v-for="step in plan.steps" :key="step.id" class="space-y-1">
+ <p>
+ <span class="font-medium">{{ t(`objects.typeManagementState.${step.state}`) }}</span> · {{ step.object.objectType }} · {{ step.object.owner }}.{{ step.object.name }}
+ </p>
+ <p v-if="step.message" class="whitespace-pre-wrap text-muted-foreground">{{ step.message }}</p>
+ </li>
+ </ol>
+ <details v-if="plan?.history.length" class="space-y-2 border-t pt-3 text-sm" data-type-execution-history>
+ <summary class="cursor-pointer">{{ t("objects.typeManagementPreviousAttempts") }}</summary>
+ <div v-for="(step, index) in plan.history" :key="`${step.id}:${index}`" class="space-y-1 pt-2">
+ <p>{{ t(`objects.typeManagementState.${step.state}`) }} · {{ step.object.objectType }} · {{ step.object.owner }}.{{ step.object.name }}</p>
+ <p v-if="step.message" class="whitespace-pre-wrap text-muted-foreground">{{ step.message }}</p>
+ <pre class="max-h-48 overflow-auto whitespace-pre-wrap rounded bg-muted p-2 font-mono text-xs">{{ step.sql }}</pre>
+ </div>
+ </details>
+ </div>
+ <DialogFooter>
+ <Button variant="outline" :disabled="executing || dataBusy" @click="close">{{ t("objects.typeManagementKeepDraft") }}</Button>
+ <Button v-if="executing" variant="outline" :disabled="stopRequested" @click="stopRequested = true">{{ t("objects.typeManagementStop") }}</Button>
+ <Button :variant="deleting ? 'destructive' : 'default'" :disabled="busy || !plan?.executable || plan.requiresReverify || (maintenanceRequired && !maintenanceConfirmed)" data-type-management-confirm @click="execute">
+ <Loader2 v-if="busy" class="h-4 w-4 animate-spin" />{{ t("objects.typeManagementConfirm") }}
+ </Button>
+ </DialogFooter>
+ </DialogContent>
+ </Dialog>
+</template>
diff --git a/apps/desktop/src/components/objects/SourceMigrationPreview.vue b/apps/desktop/src/components/objects/SourceMigrationPreview.vue
new file mode 100644
index 0000000000..105eea33e0
--- /dev/null
+++ b/apps/desktop/src/components/objects/SourceMigrationPreview.vue
@@ -0,0 +1,117 @@
+<script setup lang="ts">
+import { computed, useId } from "vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+
+export interface SourceMigrationEntry {
+ key: string;
+ name: string;
+ owner?: string;
+ objectType: string;
+ source: string;
+ draft: string;
+ generated: string;
+ rewriteRequired: boolean;
+ editable?: boolean;
+ showOriginal?: boolean;
+ currentSource?: string;
+}
+export interface SourceMigrationIssue {
+ objectKey?: string;
+ label?: string;
+ message: string;
+ repairable: boolean;
+}
+const props = defineProps<{
+ entries: SourceMigrationEntry[];
+ issues: SourceMigrationIssue[];
+ drafts: Record<string, string>;
+ statements: string[];
+ loading: boolean;
+ validating: boolean;
+ executing: boolean;
+ executable: boolean;
+ ready: boolean;
+ draftLabel?: string;
+ validationPendingMessage?: string;
+}>();
+const emit = defineEmits<{ edit: [key: string, source: string]; validate: []; reload: [] }>();
+const { t } = useI18n();
+const id = useId();
+const busy = computed(() => props.loading || props.validating || props.executing);
+const assigned = computed(() => new Set(props.entries.map((entry) => entry.key)));
+const statementsCurrent = computed(() => props.entries.every((entry) => isCurrentDraft(entry.key, entry.draft)));
+const issuesFor = (key: string) => props.issues.filter((issue) => issue.objectKey === key);
+function isCurrentDraft(key: string, draft: string) {
+ return (props.drafts[key] ?? draft) === draft;
+}
+</script>
+
+<template>
+ <section class="space-y-3 text-sm" :aria-busy="busy">
+ <slot />
+ <p v-if="loading || validating" role="status" class="text-muted-foreground">{{ t("common.loading") }}</p>
+ <p v-else-if="!executable" role="status" class="text-destructive">{{ validationPendingMessage ?? t("objects.viewRenameValidationPending") }}</p>
+ <ul v-if="issues.some((issue) => !issue.objectKey || !assigned.has(issue.objectKey))" class="space-y-2" aria-live="polite">
+ <li v-for="(issue, index) in issues.filter((item) => !item.objectKey || !assigned.has(item.objectKey))" :key="index" class="rounded border border-destructive/40 p-3">
+ <p class="font-medium text-destructive">{{ issue.label || t("objects.viewRenameNeedsRepair") }}</p>
+ <p v-if="!issue.repairable" class="text-xs text-destructive">{{ t("objects.viewRenameMetadataProblem") }}</p>
+ <details class="mt-1 text-xs text-muted-foreground" data-diagnostics>
+ <summary class="cursor-pointer">{{ t("objects.viewRenameDiagnostics") }}</summary>
+ <pre class="mt-1 whitespace-pre-wrap break-all">{{ issue.message }}</pre>
+ </details>
+ </li>
+ </ul>
+ <details v-for="(entry, index) in entries" :key="entry.key" :open="issuesFor(entry.key).length > 0" class="rounded border border-border" :data-source-name="entry.key">
+ <summary class="flex cursor-pointer items-center justify-between gap-3 px-3 py-2 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring">
+ <span class="min-w-0 break-all font-medium">{{ entry.objectType }} · {{ entry.owner ? `${entry.owner}.` : "" }}{{ entry.name }}</span>
+ <span class="shrink-0 rounded bg-muted px-2 py-0.5 text-xs" :class="issuesFor(entry.key).length ? 'text-destructive' : 'text-muted-foreground'">{{ t(issuesFor(entry.key).length ? "objects.viewRenameNeedsRepair" : "objects.viewRenameDefinitionReady") }}</span>
+ </summary>
+ <div class="space-y-3 border-t border-border p-3">
+ <details v-if="entry.showOriginal && entry.source" class="text-xs text-muted-foreground">
+ <summary class="cursor-pointer">{{ t("contextMenu.viewSource") }}</summary>
+ <pre class="mt-2 max-h-64 overflow-auto whitespace-pre-wrap break-all rounded bg-muted p-2 font-mono">{{ entry.source }}</pre>
+ </details>
+ <details v-if="entry.currentSource && entry.currentSource !== entry.source && entry.currentSource !== (drafts[entry.key] ?? entry.draft)" open class="text-xs text-muted-foreground" data-current-source>
+ <summary class="cursor-pointer">{{ t("objects.typeManagementCurrentSource") }}</summary>
+ <pre class="mt-2 max-h-64 overflow-auto whitespace-pre-wrap break-all rounded bg-muted p-2 font-mono">{{ entry.currentSource }}</pre>
+ </details>
+ <ul v-if="issuesFor(entry.key).length" class="space-y-2" aria-live="polite">
+ <li v-for="(issue, issueIndex) in issuesFor(entry.key)" :key="issueIndex" class="space-y-1">
+ <p class="font-medium text-destructive">{{ entry.name }} · {{ t("objects.viewRenameNeedsRepair") }}</p>
+ <p v-if="!issue.repairable" class="text-xs text-destructive">{{ t("objects.viewRenameMetadataProblem") }}</p>
+ <details class="text-xs text-muted-foreground" data-diagnostics>
+ <summary class="cursor-pointer">{{ t("objects.viewRenameDiagnostics") }}</summary>
+ <pre class="mt-1 whitespace-pre-wrap break-all">{{ issue.message }}</pre>
+ </details>
+ </li>
+ </ul>
+ <label v-if="entry.rewriteRequired" class="block space-y-1" :for="`${id}-draft-${index}`">
+ <span class="block text-xs text-muted-foreground">{{ draftLabel ?? t("objects.viewRenameDraft") }} · {{ entry.owner ? `${entry.owner}.` : "" }}{{ entry.name }}</span>
+ <textarea
+ :id="`${id}-draft-${index}`"
+ :value="drafts[entry.key] ?? entry.draft"
+ :disabled="busy || entry.editable === false"
+ spellcheck="false"
+ rows="10"
+ class="w-full resize-y rounded border border-input bg-background p-2 font-mono text-xs leading-relaxed focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50"
+ :data-source-draft="entry.key"
+ @input="emit('edit', entry.key, ($event.target as HTMLTextAreaElement).value)"
+ />
+ </label>
+ <div v-if="entry.generated && isCurrentDraft(entry.key, entry.draft)" class="space-y-1">
+ <p class="text-xs text-muted-foreground">{{ t("objects.viewRenameFinalSql") }}</p>
+ <pre class="max-h-48 overflow-auto whitespace-pre-wrap break-all rounded bg-muted p-2 font-mono text-xs">{{ entry.generated }}</pre>
+ </div>
+ </div>
+ </details>
+ <details v-if="statementsCurrent && statements.length" class="rounded border border-border" open>
+ <summary class="cursor-pointer px-3 py-2 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring">{{ t("objects.viewRenameFinalSql") }}</summary>
+ <pre class="max-h-64 overflow-auto whitespace-pre-wrap break-all border-t border-border p-3 font-mono text-xs">{{ statements.join("\n\n") }}</pre>
+ </details>
+ <div class="flex flex-wrap gap-2">
+ <Button type="button" variant="outline" size="sm" :disabled="busy || !ready" data-validate @click="emit('validate')">{{ t("objects.viewRenameValidate") }}</Button>
+ <Button type="button" variant="outline" size="sm" :disabled="busy" data-reload @click="emit('reload')">{{ t("objects.viewRenameReload") }}</Button>
+ </div>
+ </section>
+</template>
diff --git a/apps/desktop/src/components/objects/__tests__/CustomTypeInfoPanel.component.spec.ts b/apps/desktop/src/components/objects/__tests__/CustomTypeInfoPanel.component.spec.ts
index fb3e7254d4..4c81b7d49c 100644
--- a/apps/desktop/src/components/objects/__tests__/CustomTypeInfoPanel.component.spec.ts
+++ b/apps/desktop/src/components/objects/__tests__/CustomTypeInfoPanel.component.spec.ts
@@ -7,12 +7,14 @@ import type { ConnectionConfig, CustomTypeDetails } from "@/types/database";
const mocks = vi.hoisted(() => ({
getCustomTypeDetails: vi.fn(),
+ getObjectSource: vi.fn(),
copyToClipboard: vi.fn(),
toast: vi.fn(),
}));
vi.mock("@/lib/backend/api", () => ({
getCustomTypeDetails: (...args: unknown[]) => mocks.getCustomTypeDetails(...args),
+ getObjectSource: (...args: unknown[]) => mocks.getObjectSource(...args),
}));
vi.mock("@/lib/common/clipboard", () => ({
copyToClipboard: (...args: unknown[]) => mocks.copyToClipboard(...args),
@@ -30,7 +32,18 @@ function passthrough(tag: string): Component {
});
}
-vi.mock("vue-i18n", () => ({ useI18n: () => ({ t: (key: string) => key }) }));
+vi.mock("vue-i18n", async () => {
+ const { default: english } = await import("@/i18n/locales/en");
+ return {
+ useI18n: () => ({
+ t: (key: string) => {
+ if (key === "oracleType.boolean.yes") return english.oracleType.boolean.yes;
+ if (key === "oracleType.boolean.no") return english.oracleType.boolean.no;
+ return key;
+ },
+ }),
+ };
+});
vi.mock("@lucide/vue", () => {
const Icon = passthrough("span");
return {
@@ -216,6 +229,309 @@ describe("CustomTypeInfoPanel", () => {
await vi.waitFor(() => expect(mocks.toast).toHaveBeenCalledWith("grid.copyFailed"));
});
+ it("renders Oracle attributes and incomplete method metadata without claiming an empty method list", async () => {
+ mocks.getCustomTypeDetails.mockResolvedValue(
+ enumDetails({
+ kind: "object",
+ members: [],
+ ddl: null,
+ oracleMetadata: {
+ typeCode: "OBJECT",
+ status: "VALID",
+ attributeCount: 1,
+ methodCount: 1,
+ bodyVisible: true,
+ bodyStatus: "VALID",
+ propertiesRead: { state: "available" },
+ bodyRead: { state: "available" },
+ attributesRead: { state: "available" },
+ methodsRead: { state: "incomplete", reason: "Dictionary count is 1 but no method row was returned." },
+ collectionRead: { state: "unsupported" },
+ attributes: [{ name: "street", ordinal: 1, typeName: "VARCHAR2", length: 80 }],
+ methods: [
+ {
+ name: "SET_STREET",
+ parameters: [{ name: "P_STREET", mode: "IN", typeName: "VARCHAR2" }],
+ results: [{ name: "RETURN_VALUE", typeName: "BOOLEAN" }],
+ parametersRead: { state: "incomplete", reason: "One argument row is unavailable." },
+ resultsRead: { state: "incomplete", reason: "Result metadata is partial." },
+ },
+ ],
+ },
+ }),
+ );
+ mocks.getObjectSource.mockResolvedValue({ source: "CREATE TYPE BODY app.address_type AS ...;", editable: false });
+ mountPanel({ connection, database: "demo", schema: "app", name: "address_type", databaseType: "oracle" });
+ await flush();
+ expect(root!.textContent).toContain("street");
+ expect(root!.textContent).toContain("VARCHAR2");
+ clickButton("oracleType.methods");
+ await flush();
+ expect(root!.textContent).toContain("Dictionary count is 1 but no method row was returned.");
+ expect(root!.textContent).not.toContain("oracleType.emptyMethods");
+ expect(root!.textContent).toContain("P_STREET");
+ expect(root!.textContent).toContain("One argument row is unavailable.");
+ expect(root!.textContent).toContain("RETURN_VALUE");
+ expect(root!.textContent).toContain("Result metadata is partial.");
+ clickButton("customType.tabs.properties");
+ await flush();
+ clickButton("oracleType.viewBody");
+ await vi.waitFor(() => expect(mocks.getObjectSource).toHaveBeenCalledWith("pg-1", "demo", "app", "address_type", "TYPE_BODY"));
+ await vi.waitFor(() => expect(root!.textContent).toContain("CREATE TYPE BODY"));
+ expect(root!.textContent).toContain("CREATE TYPE BODY");
+ });
+
+ it("uses real locale strings for Oracle boolean properties", async () => {
+ mocks.getCustomTypeDetails.mockResolvedValue(
+ enumDetails({
+ kind: "object",
+ members: [],
+ ddl: null,
+ oracleMetadata: {
+ isFinal: true,
+ instantiable: false,
+ propertiesRead: { state: "available" },
+ bodyRead: { state: "unsupported" },
+ attributesRead: { state: "available" },
+ methodsRead: { state: "available" },
+ collectionRead: { state: "unsupported" },
+ attributes: [],
+ methods: [],
+ },
+ }),
+ );
+ mountPanel({ connection, database: "demo", schema: "app", name: "status", databaseType: "oracle" });
+ await flush();
+ clickButton("customType.tabs.properties");
+ await flush();
+ expect(root!.textContent).toContain("Yes");
+ expect(root!.textContent).toContain("No");
+ expect(root!.textContent).not.toContain("common.yes");
+ expect(root!.textContent).not.toContain("common.no");
+ });
+
+ it("shows collection element length and dictionary visibility, and preserves details during refresh", async () => {
+ const collectionDetails = enumDetails({
+ kind: "collection",
+ members: [],
+ ddl: null,
+ oracleMetadata: {
+ status: undefined,
+ bodyVisible: false,
+ bodyRead: { state: "available" },
+ propertiesRead: { state: "available" },
+ attributesRead: { state: "available" },
+ methodsRead: { state: "unavailable", reason: "Methods are not visible." },
+ collectionRead: { state: "unavailable", reason: "Collection metadata is not visible." },
+ collection: { kind: "VARRAY", elementName: "VARCHAR2", length: 30, upperBound: 10 },
+ attributes: [],
+ methods: [],
+ },
+ });
+ mocks.getCustomTypeDetails.mockResolvedValueOnce(collectionDetails);
+ let releaseRefresh!: (value: CustomTypeDetails) => void;
+ mocks.getCustomTypeDetails.mockReturnValueOnce(new Promise((resolve) => (releaseRefresh = resolve)));
+ mountPanel({ connection, database: "demo", schema: "app", name: "name_list", databaseType: "oracle" });
+ await flush();
+ expect(root!.textContent).toContain("oracleType.length: 30");
+ expect(root!.textContent).toContain("oracleType.bodyNotVisible");
+ expect(root!.textContent).toContain("oracleType.unknown");
+ expect(root!.textContent).toContain("Collection metadata is not visible.");
+ expect(root!.textContent).not.toContain("oracleType.emptyAttributes");
+
+ clickButton("oracleType.methods");
+ await flush();
+ expect(root!.textContent).toContain("Methods are not visible.");
+ const refresh = root!.querySelector<HTMLButtonElement>('button[aria-label="common.retry"]');
+ refresh?.dispatchEvent(new MouseEvent("click"));
+ await flush();
+ expect(mocks.getCustomTypeDetails).toHaveBeenCalledTimes(2);
+ expect(root!.textContent).toContain("Methods are not visible.");
+ expect(root!.textContent).not.toContain("Cannot read properties");
+ clickButton("customType.tabs.properties");
+ await flush();
+ expect(root!.textContent).toContain("oracleType.length: 30");
+ releaseRefresh(collectionDetails);
+ await flush();
+ });
+
+ it("refreshes Oracle details and current source while discarding both older responses", async () => {
+ const oracleDetails = enumDetails({
+ kind: "object",
+ members: [],
+ ddl: null,
+ oracleMetadata: {
+ propertiesRead: { state: "available" },
+ bodyRead: { state: "unsupported" },
+ attributesRead: { state: "available" },
+ methodsRead: { state: "available" },
+ collectionRead: { state: "unsupported" },
+ attributes: [{ name: "street", ordinal: 1, typeName: "VARCHAR2", length: 30 }],
+ methods: [],
+ },
+ });
+ mocks.getCustomTypeDetails.mockResolvedValueOnce(oracleDetails);
+ mocks.getObjectSource.mockResolvedValueOnce({ source: "OLD_TYPE_SOURCE", editable: false });
+ const panel = ref<InstanceType<typeof CustomTypeInfoPanel> | null>(null);
+ const Host = defineComponent({
+ setup() {
+ return () => h(CustomTypeInfoPanel, { ref: panel, connection, database: "demo", schema: "app", name: "address_type", databaseType: "oracle" });
+ },
+ });
+ root = document.createElement("div");
+ document.body.append(root);
+ app = createApp(Host);
+ app.mount(root);
+ await vi.waitFor(() => expect(mocks.getObjectSource).toHaveBeenCalledTimes(1));
+ clickButton("oracleType.source");
+ await vi.waitFor(() => expect(root!.textContent).toContain("OLD_TYPE_SOURCE"));
+ clickButton("customType.tabs.members");
+ await flush();
+ expect(root!.textContent).toContain("street");
+ clickButton("oracleType.source");
+ await flush();
+
+ let releaseOldDetails!: (value: CustomTypeDetails) => void;
+ let releaseFreshDetails!: (value: CustomTypeDetails) => void;
+ let releaseOldSource!: (value: { source: string; editable: boolean }) => void;
+ let releaseFreshSource!: (value: { source: string; editable: boolean }) => void;
+ mocks.getCustomTypeDetails.mockReturnValueOnce(new Promise((resolve) => (releaseOldDetails = resolve))).mockReturnValueOnce(new Promise((resolve) => (releaseFreshDetails = resolve)));
+ mocks.getObjectSource.mockReturnValueOnce(new Promise((resolve) => (releaseOldSource = resolve))).mockReturnValueOnce(new Promise((resolve) => (releaseFreshSource = resolve)));
+
+ const refreshButton = root!.querySelector<HTMLButtonElement>('button[aria-label="common.retry"]');
+ refreshButton?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+ await panel.value?.refresh();
+ await vi.waitFor(() => {
+ expect(mocks.getCustomTypeDetails).toHaveBeenCalledTimes(3);
+ expect(mocks.getObjectSource).toHaveBeenCalledTimes(3);
+ });
+ clickButton("customType.tabs.members");
+ await flush();
+ expect(root!.textContent).toContain("street");
+ clickButton("oracleType.source");
+ await flush();
+ expect(root!.textContent).toContain("OLD_TYPE_SOURCE");
+
+ releaseOldDetails(enumDetails({ name: "stale_type" }));
+ releaseOldSource({ source: "STALE_TYPE_SOURCE", editable: false });
+ await flush();
+ expect(root!.textContent).not.toContain("STALE_TYPE_SOURCE");
+ expect(root!.textContent).not.toContain("stale_type");
+ releaseFreshDetails(oracleDetails);
+ releaseFreshSource({ source: "FRESH_TYPE_SOURCE", editable: false });
+ await vi.waitFor(() => expect(root!.textContent).toContain("FRESH_TYPE_SOURCE"));
+ clickButton("customType.tabs.members");
+ await flush();
+ expect(root!.textContent).toContain("street");
+ expect(root!.textContent).not.toContain("STALE_TYPE_SOURCE");
+ expect(root!.textContent).not.toContain("stale_type");
+ });
+
+ it("keeps type details visible when Oracle source reading fails and retries only source", async () => {
+ mocks.getCustomTypeDetails.mockResolvedValue(
+ enumDetails({
+ kind: "object",
+ members: [],
+ ddl: null,
+ oracleMetadata: {
+ typeCode: "OBJECT",
+ propertiesRead: { state: "available" },
+ bodyRead: { state: "unsupported" },
+ attributesRead: { state: "available" },
+ methodsRead: { state: "available" },
+ collectionRead: { state: "unsupported" },
+ attributes: [],
+ methods: [],
+ },
+ }),
+ );
+ mocks.getObjectSource.mockRejectedValueOnce(new Error("source dictionary denied")).mockResolvedValueOnce({ source: "CREATE TYPE app.status AS OBJECT (...);", editable: false });
+ mountPanel({ connection, database: "demo", schema: "app", name: "status", databaseType: "oceanbase-oracle" });
+ await flush();
+ clickButton("oracleType.source");
+ await flush();
+ expect(root!.textContent).toContain("source dictionary denied");
+ clickButton("customType.tabs.properties");
+ await flush();
+ expect(root!.textContent).toContain("app");
+ clickButton("oracleType.source");
+ await flush();
+ const sourceRetry = root!.querySelector("section button");
+ expect(sourceRetry?.textContent).toContain("common.retry");
+ sourceRetry?.dispatchEvent(new MouseEvent("click"));
+ await vi.waitFor(() => expect(mocks.getObjectSource).toHaveBeenCalledTimes(2));
+ await vi.waitFor(() => expect(root!.textContent).toContain("CREATE TYPE app.status"));
+ expect(mocks.getCustomTypeDetails).toHaveBeenCalledTimes(1);
+ });
+
+ it("loads Oracle source even when type metadata fails", async () => {
+ mocks.getCustomTypeDetails.mockRejectedValue(new Error("metadata unavailable"));
+ mocks.getObjectSource.mockResolvedValue({ source: "CREATE TYPE app.status AS OBJECT (...);", editable: false });
+ mountPanel({ connection, database: "demo", schema: "app", name: "status", databaseType: "dameng" });
+ await vi.waitFor(() => expect(root!.textContent).toContain("CREATE TYPE app.status"));
+ expect(root!.textContent).toContain("metadata unavailable");
+ expect(mocks.getObjectSource).toHaveBeenCalledWith("pg-1", "demo", "app", "status", "TYPE");
+ });
+
+ it("discards a late Oracle source result after the selected type changes", async () => {
+ const oracleDetails = enumDetails({
+ kind: "object",
+ members: [],
+ ddl: null,
+ oracleMetadata: {
+ propertiesRead: { state: "available" },
+ bodyRead: { state: "unsupported" },
+ attributesRead: { state: "available" },
+ methodsRead: { state: "available" },
+ collectionRead: { state: "unsupported" },
+ attributes: [],
+ methods: [],
+ },
+ });
+ mocks.getCustomTypeDetails.mockResolvedValue(oracleDetails);
+ let releaseFirst!: (value: { source: string; editable: boolean }) => void;
+ mocks.getObjectSource.mockReturnValueOnce(new Promise((resolve) => (releaseFirst = resolve))).mockResolvedValueOnce({ source: "FRESH_TYPE_SOURCE", editable: false });
+ const hostName = ref("first_type");
+ const Host = defineComponent({
+ setup() {
+ return () => h(CustomTypeInfoPanel, { connection, database: "demo", schema: "app", name: hostName.value, databaseType: "oracle" });
+ },
+ });
+ root = document.createElement("div");
+ document.body.append(root);
+ app = createApp(Host);
+ app.mount(root);
+ await flush();
+ hostName.value = "second_type";
+ await vi.waitFor(() => expect(mocks.getObjectSource).toHaveBeenCalledTimes(2));
+ clickButton("oracleType.source");
+ await vi.waitFor(() => expect(root!.textContent).toContain("FRESH_TYPE_SOURCE"));
+ releaseFirst({ source: "STALE_TYPE_SOURCE", editable: false });
+ await flush();
+ expect(root!.textContent).toContain("second_type");
+ expect(root!.textContent).not.toContain("STALE_TYPE_SOURCE");
+ });
+
+ it("keeps an explicitly selected tab when details finish loading", async () => {
+ let release!: (details: CustomTypeDetails) => void;
+ mocks.getCustomTypeDetails.mockReturnValueOnce(new Promise((resolve) => (release = resolve)));
+ const panel = ref<InstanceType<typeof CustomTypeInfoPanel> | null>(null);
+ const Host = defineComponent({
+ setup() {
+ return () => h(CustomTypeInfoPanel, { ref: panel, connection, database: "demo", schema: "app", name: "status" });
+ },
+ });
+ root = document.createElement("div");
+ document.body.append(root);
+ app = createApp(Host);
+ app.mount(root);
+ await nextTick();
+ panel.value?.selectTab("ddl");
+ release(enumDetails());
+ await flush();
+ expect(root!.querySelector("pre")?.textContent).toContain("CREATE TYPE");
+ });
+
it("ignores a stale response when the type is switched quickly on the same instance", async () => {
let releaseFirst!: () => void;
const first = new Promise<CustomTypeDetails>((resolve) => (releaseFirst = () => resolve(enumDetails({ name: "status" }))));
diff --git a/apps/desktop/src/components/objects/__tests__/ObjectBrowser.invalidTypeSource.integration.spec.ts b/apps/desktop/src/components/objects/__tests__/ObjectBrowser.invalidTypeSource.integration.spec.ts
new file mode 100644
index 0000000000..078ada4b27
--- /dev/null
+++ b/apps/desktop/src/components/objects/__tests__/ObjectBrowser.invalidTypeSource.integration.spec.ts
@@ -0,0 +1,110 @@
+// @vitest-environment happy-dom
+import { createApp, defineComponent, h, nextTick, ref, type App } from "vue";
+import { createPinia, disposePinia, setActivePinia, type Pinia } from "pinia";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import ObjectBrowser from "@/components/objects/ObjectBrowser.vue";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useQueryStore } from "@/stores/queryStore";
+import { invalidateObjectBrowserRowsCache } from "@/lib/table/objectBrowserRowsCache";
+import type { ConnectionConfig } from "@/types/database";
+
+const backend = vi.hoisted(() => ({
+ listObjects: vi.fn(),
+ listSchemas: vi.fn(async () => []),
+ listObjectStatistics: vi.fn(async () => []),
+ getObjectSource: vi.fn(),
+ buildEditableObjectSource: vi.fn(async (input: { source: string }) => input.source),
+ checkConnectionHealth: vi.fn(async () => undefined),
+ saveOpenTabsState: vi.fn(async () => undefined),
+ loadOpenTabsState: vi.fn(async () => ({ tabs: [], activeTabId: null })),
+ executeQuery: vi.fn(),
+ closeClientConnectionSession: vi.fn(async () => true),
+ listDetachedTabHandoffs: vi.fn(async () => []),
+ subscribeConnectionLiveness: vi.fn(async () => () => {}),
+ subscribeConnectionIdleClosed: vi.fn(async () => () => {}),
+ invalidType: "TYPE",
+}));
+vi.mock("@/lib/backend/api", async (original) => ({ ...(await original<typeof import("@/lib/backend/api")>()), ...backend }));
+vi.mock("vue-i18n", async (original) => ({ ...(await original<typeof import("vue-i18n")>()), useI18n: () => ({ t: (key: string) => key, locale: ref("en-US") }) }));
+vi.mock("@/composables/useSqlHighlighter", () => ({ useSqlHighlighter: () => ({ highlight: (sql: string) => sql }) }));
+vi.mock("@/components/objects/OracleInvalidObjectsDialog.vue", () => ({
+ default: defineComponent({
+ props: { open: Boolean },
+ emits: ["open-source", "update:open"],
+ setup(props, { emit }) {
+ return () => (props.open ? h("button", { "data-repair-source": "", onClick: () => emit("open-source", { owner: "APP", name: "T_BAD", type: backend.invalidType }) }, "repair source") : null);
+ },
+ }),
+}));
+vi.mock("vue-virtual-scroller", () => ({
+ RecycleScroller: defineComponent({
+ props: { items: { type: Array, default: () => [] } },
+ setup(props, { slots }) {
+ return () =>
+ h(
+ "div",
+ props.items.map((item) => slots.default?.({ item })),
+ );
+ },
+ }),
+}));
+vi.mock("@/components/ui/searchable-select", () => ({ SearchableSelect: { render: () => null } }));
+vi.mock("@/components/ui/ToolbarOverflowMenu.vue", () => ({ default: { render: () => null } }));
+vi.mock("@/components/editor/QueryEditor.vue", () => ({ default: { render: () => null } }));
+vi.mock("@/components/objects/CustomTypeInfoPanel.vue", () => ({ default: { render: () => null } }));
+
+const connection = { id: "invalid-type-source", name: "Oracle test", db_type: "oracle", host: "localhost", port: 1521, username: "APP", password: "" } as ConnectionConfig;
+let pinia: Pinia;
+let app: App;
+let host: HTMLElement;
+
+beforeEach(() => {
+ vi.clearAllMocks();
+ pinia = createPinia();
+ setActivePinia(pinia);
+ const connections = useConnectionStore();
+ connections.connections = [connection];
+ connections.connectedIds.add(connection.id);
+ invalidateObjectBrowserRowsCache({});
+});
+afterEach(() => {
+ app?.unmount();
+ host?.remove();
+ disposePinia(pinia);
+ setActivePinia(undefined);
+ invalidateObjectBrowserRowsCache({});
+});
+
+describe("invalid TYPE repair through the real object browser and source store", () => {
+ it.each([
+ ["TYPE", "TYPE"],
+ ["TYPE BODY", "TYPE_BODY"],
+ ] as const)("opens %s in controlled source editing instead of a generic runnable SQL tab", async (dictionaryType, objectType) => {
+ backend.invalidType = dictionaryType;
+ const source = `CREATE OR REPLACE ${dictionaryType} APP.T_BAD AS ${objectType === "TYPE" ? "OBJECT (ID NUMBER)" : "MEMBER FUNCTION F RETURN NUMBER AS BEGIN RETURN NO_FIELD; END; END"};`;
+ backend.listObjects.mockResolvedValue([{ name: "T_BAD", schema: "APP", object_type: objectType }]);
+ backend.getObjectSource.mockResolvedValue({ name: "T_BAD", object_type: objectType, source, editable: true });
+ host = document.createElement("div");
+ document.body.append(host);
+ app = createApp({ setup: () => () => h(ObjectBrowser, { connection, database: "ORCL", schema: "APP" }) });
+ app.use(pinia).mount(host);
+ await vi.waitFor(() => expect(host.textContent).toContain("T_BAD"));
+ const open = [...host.querySelectorAll<HTMLButtonElement>("button")].find((button) => button.textContent?.includes("processList.oracleInvalidObjects.title"));
+ expect(open).toBeDefined();
+ open!.click();
+ await nextTick();
+ host.querySelector<HTMLButtonElement>("[data-repair-source]")!.click();
+ const store = useQueryStore();
+ await vi.waitFor(() => expect(store.tabs).toHaveLength(1));
+ await vi.waitFor(() => expect(store.tabs[0].sourceLoad).toBeUndefined());
+ const tab = store.tabs[0];
+ expect(tab.objectSource).toMatchObject({ schema: "APP", name: "T_BAD", objectType });
+ expect(tab.objectDetails).toMatchObject({ schema: "APP", name: "T_BAD", objectType, section: "source" });
+ expect(tab.typeSourceEditing).toBe(true);
+ expect(tab.sourceView).toBe(true);
+ expect(tab.sql).toBe(source);
+ await expect(store.executeTabSql(tab.id, source)).rejects.toThrow();
+ expect(backend.executeQuery).not.toHaveBeenCalled();
+ await vi.waitFor(() => expect(host.querySelector("[data-repair-source]")).toBeNull());
+ });
+});
diff --git a/apps/desktop/src/components/objects/__tests__/ObjectBrowser.routineSourceTab.component.spec.ts b/apps/desktop/src/components/objects/__tests__/ObjectBrowser.routineSourceTab.component.spec.ts
index c273d81572..2c1652cb98 100644
--- a/apps/desktop/src/components/objects/__tests__/ObjectBrowser.routineSourceTab.component.spec.ts
+++ b/apps/desktop/src/components/objects/__tests__/ObjectBrowser.routineSourceTab.component.spec.ts
@@ -16,6 +16,7 @@ const mocks = vi.hoisted(() => ({
ensureConnected: vi.fn(),
openObjectSourceTabPending: vi.fn(),
toast: vi.fn(),
+ typePanelRefresh: vi.fn(),
editorSettings: {
shortcuts: { refreshData: "F5" },
objectBrowserViewMode: "list",
@@ -88,7 +89,15 @@ vi.mock("@/components/ui/CustomContextMenu.vue", () => ({
vi.mock("@/components/editor/QueryEditor.vue", () => ({ default: { render: () => null } }));
vi.mock("@/components/editor/DangerConfirmDialog.vue", () => ({ default: { render: () => null } }));
vi.mock("@/components/objects/ProcedureExecutionDialog.vue", () => ({ default: { render: () => null } }));
-vi.mock("@/components/objects/CustomTypeInfoPanel.vue", () => ({ default: { render: () => null } }));
+vi.mock("@/components/objects/CustomTypeInfoPanel.vue", () => ({
+ default: defineComponent({
+ props: { name: { type: String, default: "" } },
+ setup(props, { expose }) {
+ expose({ selectTab: vi.fn(), refresh: mocks.typePanelRefresh });
+ return () => h("div", { "data-custom-type-panel": true }, props.name);
+ },
+ }),
+}));
vi.mock("@/components/export/XlsxHeaderDialog.vue", () => ({ default: { render: () => null } }));
const connection = {
@@ -134,13 +143,13 @@ afterEach(() => {
invalidateObjectBrowserRowsCache({});
});
-async function mountBrowser() {
+async function mountBrowser(browserConnection: ConnectionConfig = connection, readyName = "sp_daily_report") {
const host = document.createElement("div");
document.body.append(host);
- const app = createApp({ setup: () => () => h(ObjectBrowser, { connection, database: "app" }) });
+ const app = createApp({ setup: () => () => h(ObjectBrowser, { connection: browserConnection, database: "app" }) });
mountedApps.push({ app, host });
app.mount(host);
- await vi.waitFor(() => expect(host.textContent).toContain("sp_daily_report"));
+ await vi.waitFor(() => expect(host.textContent).toContain(readyName));
return host;
}
@@ -155,6 +164,26 @@ function click(row: HTMLElement, detail: number) {
}
describe("ObjectBrowser routine double click", () => {
+ it("opens Oracle TYPE details and reads TYPE_BODY through the existing source panel", async () => {
+ const oracleConnection = { ...connection, id: "oracle-1", db_type: "oracle" } as ConnectionConfig;
+ mocks.listObjects.mockResolvedValue([
+ { name: "address_type", schema: "app", object_type: "TYPE" },
+ { name: "address_type_body", schema: "app", object_type: "TYPE_BODY" },
+ ]);
+ mocks.getObjectSource.mockResolvedValue({ source: "CREATE TYPE BODY app.address_type_body AS ...;", editable: false });
+ const host = await mountBrowser(oracleConnection, "address_type");
+
+ click(rowFor(host, "address_type"), 1);
+ await vi.waitFor(() => expect(host.textContent).toContain("address_type"));
+ const refresh = host.querySelector<HTMLButtonElement>('button[title^="grid.refresh"]');
+ refresh?.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+ await vi.waitFor(() => expect(mocks.typePanelRefresh).toHaveBeenCalledTimes(1));
+
+ click(rowFor(host, "address_type_body"), 1);
+ await vi.waitFor(() => expect(mocks.getObjectSource).toHaveBeenCalledWith("oracle-1", "app", "app", "address_type_body", "TYPE_BODY", undefined));
+ expect(mocks.buildEditableObjectSource).not.toHaveBeenCalled();
+ });
+
it.each(["", "v integer", "v INOUT integer"])("keeps the selected Kingbase overload in its DROP preview (%j)", async (signature) => {
connection.db_type = "kingbase";
mocks.listObjects.mockResolvedValue([{ name: "sp_daily_report", schema: "app", object_type: "PROCEDURE", signature }]);
diff --git a/apps/desktop/src/components/objects/__tests__/ObjectBrowser.viewSourceSave.spec.ts b/apps/desktop/src/components/objects/__tests__/ObjectBrowser.viewSourceSave.spec.ts
index 4ec823a2a2..3aadfda7ea 100644
--- a/apps/desktop/src/components/objects/__tests__/ObjectBrowser.viewSourceSave.spec.ts
+++ b/apps/desktop/src/components/objects/__tests__/ObjectBrowser.viewSourceSave.spec.ts
@@ -385,21 +385,20 @@ describe("ObjectBrowser view source save", () => {
it.each([
["PACKAGE BODY", "PACKAGE_BODY"],
["MATERIALIZED VIEW", "MATERIALIZED_VIEW"],
+ ["TYPE", "TYPE"],
+ ["TYPE BODY", "TYPE_BODY"],
])("opens supported %s through the normalized source-tab request", async (type, kind) => {
mocks.invalidObjectType = type;
const host = await mountBrowser(oracleConnection, "ORCL");
[...host.querySelectorAll<HTMLButtonElement>("button")].find((button) => button.textContent?.includes("processList.oracleInvalidObjects.title"))?.click();
await nextTick();
host.querySelector<HTMLButtonElement>("[data-invalid-object-dialog] button")?.click();
- expect(mocks.openObjectSourceTabPending).toHaveBeenCalledWith(expect.objectContaining({ request: { name: "P_BAD", objectType: kind } }));
+ expect(mocks.openObjectSourceTabPending).toHaveBeenCalledWith(expect.objectContaining({ schema: "APP", initialEditing: true, request: { name: "P_BAD", objectType: kind } }));
+ expect(mocks.createTab).not.toHaveBeenCalled();
await vi.waitFor(() => expect(host.querySelector("[data-invalid-object-dialog]")).toBeNull());
});
- it.each([
- ["TYPE", "TYPE"],
- ["TYPE BODY", "TYPE_BODY"],
- ["TRIGGER", "TRIGGER"],
- ])("keeps the supported %s repair path usable", async (type, kind) => {
+ it.each([["TRIGGER", "TRIGGER"]])("keeps the supported %s repair path usable", async (type, kind) => {
mocks.invalidObjectType = type;
const source = `CREATE OR REPLACE ${type} P_BAD`;
mocks.getObjectSource.mockResolvedValueOnce({ source, editable: true });
@@ -470,22 +469,22 @@ describe("ObjectBrowser view source save", () => {
expect(mocks.toast).not.toHaveBeenCalled();
});
- it("does not create a repair tab or toast when an Oracle TYPE source request returns after unmount", async () => {
+ it("does not create a repair tab or toast when a TRIGGER source request returns after unmount", async () => {
let release!: (value: { source: string; editable: boolean }) => void;
- mocks.invalidObjectType = "TYPE";
+ mocks.invalidObjectType = "TRIGGER";
mocks.getObjectSource.mockReturnValueOnce(new Promise((resolve) => (release = resolve)));
const host = await mountBrowser(oracleConnection, "ORCL");
const opener = [...host.querySelectorAll<HTMLButtonElement>("button")].find((button) => button.textContent?.includes("processList.oracleInvalidObjects.title"));
opener?.click();
await nextTick();
host.querySelector<HTMLButtonElement>("[data-invalid-object-dialog] button")?.click();
- await vi.waitFor(() => expect(mocks.getObjectSource).toHaveBeenCalledWith(oracleConnection.id, "ORCL", "APP", "P_BAD", "TYPE"));
+ await vi.waitFor(() => expect(mocks.getObjectSource).toHaveBeenCalledWith(oracleConnection.id, "ORCL", "APP", "P_BAD", "TRIGGER"));
const mounted = mountedApps.splice(
mountedApps.findIndex((item) => item.host === host),
1,
)[0]!;
mounted.app.unmount();
- release({ source: "CREATE TYPE P_BAD AS OBJECT (...)", editable: true });
+ release({ source: "CREATE TRIGGER P_BAD BEFORE INSERT ON T BEGIN NULL; END;", editable: true });
await Promise.resolve();
await nextTick();
expect(mocks.openObjectSourceTabPending).not.toHaveBeenCalled();
@@ -493,6 +492,28 @@ describe("ObjectBrowser view source save", () => {
host.remove();
});
+ it("does not create another TYPE tab or toast when its pending source finishes after unmount", async () => {
+ mocks.invalidObjectType = "TYPE";
+ mocks.deferSourceTabLoad = true;
+ const host = await mountBrowser(oracleConnection, "ORCL");
+ [...host.querySelectorAll<HTMLButtonElement>("button")].find((button) => button.textContent?.includes("processList.oracleInvalidObjects.title"))?.click();
+ await nextTick();
+ host.querySelector<HTMLButtonElement>("[data-invalid-object-dialog] button")?.click();
+ await vi.waitFor(() => expect(mocks.finishSourceTabLoad).toBeTypeOf("function"));
+ expect(mocks.openObjectSourceTabPending).toHaveBeenCalledOnce();
+ const mounted = mountedApps.splice(
+ mountedApps.findIndex((item) => item.host === host),
+ 1,
+ )[0]!;
+ mounted.app.unmount();
+ mocks.finishSourceTabLoad?.();
+ await nextTick();
+ expect(mocks.openObjectSourceTabPending).toHaveBeenCalledOnce();
+ expect(mocks.createTab).not.toHaveBeenCalled();
+ expect(mocks.toast).not.toHaveBeenCalled();
+ host.remove();
+ });
+
it("does not dispatch a save whose source identity changed during SQL construction", async () => {
const host = await mountBrowser();
vi.useFakeTimers();
diff --git a/apps/desktop/src/components/objects/__tests__/ObjectSourceDialog.oceanbaseSequence.spec.ts b/apps/desktop/src/components/objects/__tests__/ObjectSourceDialog.oceanbaseSequence.spec.ts
index 57d800f949..6befe6c953 100644
--- a/apps/desktop/src/components/objects/__tests__/ObjectSourceDialog.oceanbaseSequence.spec.ts
+++ b/apps/desktop/src/components/objects/__tests__/ObjectSourceDialog.oceanbaseSequence.spec.ts
@@ -4,7 +4,7 @@ import { createPinia, setActivePinia } from "pinia";
import { createI18n } from "vue-i18n";
import { EditorState } from "@codemirror/state";
import { EditorView } from "@codemirror/view";
-import { afterEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { useConnectionStore } from "@/stores/connectionStore";
import { useProductionSafetyStore } from "@/stores/productionSafetyStore";
import type { ConnectionConfig, DatabaseType, ObjectSourceKind } from "@/types/database";
@@ -19,6 +19,14 @@ const mocks = vi.hoisted(() => ({
buildEditableObjectSource: vi.fn(),
buildExecutableObjectSourceStatements: vi.fn(),
executeQuery: vi.fn(),
+ checkConnectionHealth: vi.fn(),
+ subscribeConnectionLiveness: vi.fn(),
+ subscribeConnectionIdleClosed: vi.fn(),
+ prewarmConnection: vi.fn(),
+ loadConnections: vi.fn(),
+ loadTunnelProfiles: vi.fn(),
+ loadTableVGroups: vi.fn(),
+ loadSidebarLayout: vi.fn(),
prepareOracleRoutineSave: vi.fn(),
updateOracleRoutineOperationReferences: vi.fn(async () => {}),
executeOracleRoutineOperation: vi.fn(),
@@ -28,10 +36,19 @@ const mocks = vi.hoisted(() => ({
// save/production-guard pipeline remain real. Rust builder tests cover the SQL.
vi.mock("@/lib/backend/api", async (importOriginal) => ({ ...(await importOriginal<typeof import("@/lib/backend/api")>()), ...mocks }));
const cleanups: Array<() => void> = [];
+const unexpectedHttp: string[] = [];
+beforeEach(() => {
+ unexpectedHttp.length = 0;
+ vi.spyOn(globalThis, "fetch").mockImplementation(async (input) => {
+ unexpectedHttp.push(String(input));
+ throw new Error(`Unexpected HTTP boundary: ${String(input)}`);
+ });
+});
afterEach(() => {
for (const cleanup of cleanups.splice(0)) cleanup();
vi.restoreAllMocks();
for (const mock of Object.values(mocks)) mock.mockReset();
+ expect(unexpectedHttp).toEqual([]);
});
function button(text: string) {
return [...document.querySelectorAll<HTMLButtonElement>("button")].find((element) => element.textContent?.trim() === text);
@@ -47,8 +64,16 @@ async function mount(options: { databaseType?: DatabaseType; initialEditing?: bo
const pinia = createPinia();
setActivePinia(pinia);
const store = useConnectionStore();
- vi.spyOn(store, "ensureConnected").mockResolvedValue(undefined);
- vi.spyOn(store, "getConfig").mockReturnValue({ id: "ob", name: "test", db_type: databaseType, is_production: options.production } as ConnectionConfig);
+ store.connections.push({ id: "ob", name: "test", db_type: databaseType, is_production: options.production } as ConnectionConfig);
+ store.connectedIds.add("ob");
+ mocks.checkConnectionHealth.mockResolvedValue(undefined);
+ mocks.subscribeConnectionLiveness.mockResolvedValue(() => {});
+ mocks.subscribeConnectionIdleClosed.mockResolvedValue(() => {});
+ mocks.prewarmConnection.mockResolvedValue(undefined);
+ mocks.loadConnections.mockResolvedValue([]);
+ mocks.loadTunnelProfiles.mockResolvedValue([]);
+ mocks.loadTableVGroups.mockResolvedValue({});
+ mocks.loadSidebarLayout.mockResolvedValue(null);
mocks.getObjectSource.mockResolvedValue({ name: "SEQ", schema: "APP", object_type: objectType, source, editable: options.editable !== false });
mocks.buildEditableObjectSource.mockResolvedValue(objectType === "SEQUENCE" && databaseType === "oceanbase-oracle" ? alter : source);
mocks.buildExecutableObjectSourceStatements.mockResolvedValue([objectType === "SEQUENCE" ? alter : source]);
@@ -70,6 +95,27 @@ async function mount(options: { databaseType?: DatabaseType; initialEditing?: bo
}
describe("OceanBase sequence source through the shared Oracle object dialog", () => {
+ it.each(["TYPE", "TYPE_BODY"] as const)("labels %s editing and save preview for the controlled TYPE flow", async (type) => {
+ const source = type === "TYPE" ? 'CREATE OR REPLACE TYPE "APP"."SEQ" AS OBJECT (ID NUMBER);' : 'CREATE OR REPLACE TYPE BODY "APP"."SEQ" AS MEMBER FUNCTION F RETURN NUMBER IS BEGIN RETURN 1; END; END;';
+ await mount({ type, source });
+ expect(editor()!.state.readOnly).toBe(true);
+ expect(button("contextMenu.editView")).toBeUndefined();
+ button("contextMenu.editObject")!.click();
+ await vi.waitFor(() => expect(editor()!.state.readOnly).toBe(false));
+ expect(document.querySelector('[role="dialog"] h2')?.textContent).toBe("contextMenu.editObject - SEQ");
+ expect(button("objects.saveSource")).toBeUndefined();
+ const requests = await import("@/lib/table/oracleTypeManagementRequest");
+ try {
+ button("objects.typeManagementPreviewSave")!.click();
+ await vi.waitFor(() => expect(requests.oracleTypeManagementRequest.value?.operation).toBe(type === "TYPE_BODY" ? "save-body" : "save-spec"));
+ expect(mocks.buildExecutableObjectSourceStatements).not.toHaveBeenCalled();
+ expect(mocks.executeQuery).not.toHaveBeenCalled();
+ } finally {
+ const pending = requests.oracleTypeManagementRequest.value;
+ if (pending) requests.finishOracleTypeManagementRequest(pending.id, { complete: false, target: pending.target, operation: pending.operation });
+ }
+ });
+
function routineOperation(source: string, valid: boolean): OracleRoutineOperation {
const identity = { owner: "APP", name: "SEQ", kind: "FUNCTION" as const };
return {
diff --git a/apps/desktop/src/components/objects/__tests__/OracleTypeManagementDialog.spec.ts b/apps/desktop/src/components/objects/__tests__/OracleTypeManagementDialog.spec.ts
new file mode 100644
index 0000000000..c47da3522c
--- /dev/null
+++ b/apps/desktop/src/components/objects/__tests__/OracleTypeManagementDialog.spec.ts
@@ -0,0 +1,485 @@
+// @vitest-environment happy-dom
+import { createApp, h, nextTick, type App } from "vue";
+import { createPinia, disposePinia, setActivePinia } from "pinia";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { ConnectionConfig, OracleTypeManagementSnapshot } from "@/types/database";
+
+const mocks = vi.hoisted(() => ({
+ getOracleTypeManagementSnapshot: vi.fn(),
+ buildOracleTypeManagementSql: vi.fn(),
+ verifyOracleTypeData: vi.fn(),
+ prepareOracleTypeEvolution: vi.fn(),
+ executeConditionalUpdate: vi.fn(),
+ cancelConditionalUpdate: vi.fn(),
+ saveOpenTabsState: vi.fn(),
+ loadOpenTabsState: vi.fn(),
+ getObjectSource: vi.fn(),
+ buildEditableObjectSource: vi.fn(async ({ source }: { source: string }) => source),
+ checkConnectionHealth: vi.fn(async () => {}),
+ deleteSchemaCachePrefix: vi.fn(async () => {}),
+ loadSchemaCache: vi.fn(async () => null),
+ saveSchemaCache: vi.fn(async () => {}),
+ subscribeConnectionLiveness: vi.fn(async () => () => {}),
+ subscribeConnectionIdleClosed: vi.fn(async () => () => {}),
+}));
+vi.mock("@/lib/backend/api", async (original) => ({ ...(await original<typeof import("@/lib/backend/api")>()), ...mocks }));
+
+const target = { connectionId: "type-dialog", database: "service", owner: "APP", name: "T", databaseType: "oceanbase-oracle" as const };
+const spec = 'CREATE OR REPLACE TYPE "APP"."T" AS OBJECT (ID NUMBER, MEMBER FUNCTION F RETURN NUMBER);';
+const body = 'CREATE OR REPLACE TYPE BODY "APP"."T" AS MEMBER FUNCTION F RETURN NUMBER AS BEGIN RETURN 1; END; END;';
+const changed = body.replace("RETURN 1", "RETURN 2");
+const read = { state: "available" as const };
+let actualBody: string;
+let actualStatus: string;
+let failure: "invalid" | "invalid-response-lost" | "unknown" | "different" | undefined;
+let saved: { tabs: unknown[]; activeTabId: string | null };
+let pinia: ReturnType<typeof createPinia>;
+let app: App | undefined;
+let host: HTMLElement | undefined;
+const clone = <T>(value: T): T => JSON.parse(JSON.stringify(value));
+
+function snapshot(): OracleTypeManagementSnapshot {
+ return {
+ target: { connectionId: target.connectionId, database: target.database, owner: target.owner, name: target.name },
+ visibilityScope: "current-user-visible-dictionaries",
+ actingUser: "APP",
+ actingUserRead: read,
+ detailsRead: read,
+ typeSource: spec,
+ typeSourceRead: read,
+ bodySource: actualBody,
+ bodySourceRead: read,
+ objects: [
+ { owner: "APP", name: "T", objectType: "TYPE", exists: true, objectId: "9007199254740993", status: "VALID", statusRead: read, source: spec, sourceRead: read, sourceFingerprint: spec, errors: [], errorsRead: read, directPrivileges: [], privilegesRead: read },
+ { owner: "APP", name: "T", objectType: "TYPE BODY", exists: true, objectId: "2", status: actualStatus, statusRead: read, source: actualBody, sourceRead: read, sourceFingerprint: actualBody, errors: [], errorsRead: read, directPrivileges: [], privilegesRead: { state: "unsupported" } },
+ ],
+ dependencies: [],
+ dependenciesRead: read,
+ persistentReferences: [],
+ persistentReferencesRead: read,
+ directPrivileges: [],
+ privilegesRead: read,
+ };
+}
+
+beforeEach(() => {
+ vi.resetModules();
+ vi.clearAllMocks();
+ mocks.cancelConditionalUpdate.mockResolvedValue({ requested: false, terminal: true, databaseTerminal: true });
+ vi.stubGlobal(
+ "EventSource",
+ class extends EventTarget {
+ onmessage = null;
+ onerror = null;
+ close() {}
+ },
+ );
+ vi.stubGlobal("localStorage", { getItem: vi.fn(() => null), setItem: vi.fn(), removeItem: vi.fn() });
+ vi.stubGlobal(
+ "fetch",
+ vi.fn(async (url) => {
+ if (String(url).endsWith("/api/tab-runtime-cache/prune")) return new Response(JSON.stringify({ deletedEntries: 0, deletedBytes: 0, orphanDeletions: 0, remainingEntries: 0, remainingBytes: 0 }), { status: 200 });
+ throw new Error(`Unmocked HTTP boundary: ${String(url)}`);
+ }),
+ );
+ pinia = createPinia();
+ setActivePinia(pinia);
+ actualBody = body;
+ actualStatus = "VALID";
+ failure = undefined;
+ saved = { tabs: [], activeTabId: null };
+ mocks.getOracleTypeManagementSnapshot.mockImplementation(async () => clone(snapshot()));
+ mocks.buildOracleTypeManagementSql.mockImplementation(async ({ source }) => ({ statements: [source], sourceFingerprint: source }));
+ mocks.saveOpenTabsState.mockImplementation(async (payload) => {
+ saved = clone(payload);
+ });
+ mocks.loadOpenTabsState.mockImplementation(async () => clone(saved));
+ mocks.getObjectSource.mockImplementation(async () => ({ name: "T", object_type: "TYPE_BODY", source: actualBody, editable: true }));
+ mocks.executeConditionalUpdate.mockImplementation(async (_connection, _database, sql) => {
+ if (failure === "unknown") throw new Error("Unknown response");
+ actualBody = failure === "different" ? sql.replace("RETURN 2", "RETURN 9") : sql;
+ actualStatus = failure === "invalid" || failure === "invalid-response-lost" ? "INVALID" : "VALID";
+ if (failure === "invalid-response-lost") throw new Error("Lost response after completed INVALID DDL");
+ return { columns: [], rows: [], execution_error: false, error: null, messages: [] };
+ });
+});
+
+afterEach(async () => {
+ const requests = await import("@/lib/table/oracleTypeManagementRequest");
+ const current = requests.oracleTypeManagementRequest.value;
+ if (current) requests.finishOracleTypeManagementRequest(current.id, { complete: false, operation: current.operation, target: current.target });
+ app?.unmount();
+ host?.remove();
+ app = undefined;
+ host = undefined;
+ disposePinia(pinia);
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ const unexpectedRequests = vi
+ .mocked(fetch)
+ .mock.calls.map(([url]) => String(url))
+ .filter((url) => !url.endsWith("/api/tab-runtime-cache/prune"));
+ expect(unexpectedRequests).toEqual([]);
+ vi.unstubAllGlobals();
+});
+
+async function mount(production = false, isCurrent = () => true, baseSource?: string, operation: "save-body" | "save-spec" = "save-body", databaseType: "oracle" | "oceanbase-oracle" = target.databaseType) {
+ const { useConnectionStore } = await import("@/stores/connectionStore");
+ const connectionStore = useConnectionStore();
+ connectionStore.connections.push({ id: target.connectionId, name: "test", db_type: databaseType, username: "APP", is_production: production } as ConnectionConfig);
+ connectionStore.connectedIds.add(target.connectionId);
+ const { useQueryStore } = await import("@/stores/queryStore");
+ const queryStore = useQueryStore();
+ await queryStore.initOpenTabs();
+ const { default: i18n, setLocale } = await import("@/i18n");
+ await setLocale("zh-CN");
+ const { default: Dialog } = await import("../OracleTypeManagementDialog.vue");
+ const requests = await import("@/lib/table/oracleTypeManagementRequest");
+ host = document.createElement("div");
+ document.body.append(host);
+ app = createApp({ render: () => h(Dialog) })
+ .use(pinia)
+ .use(i18n);
+ app.mount(host);
+ const outcome = requests.requestOracleTypeManagement({ target: { ...target, databaseType }, operation, source: operation === "save-body" ? changed : spec.replace("ID NUMBER", "ID NUMBER, LABEL VARCHAR2(40)"), baseSource, isCurrent });
+ await vi.waitFor(() => expect(document.querySelector<HTMLTextAreaElement>("[data-source-draft]")?.disabled).toBe(false));
+ return { queryStore, outcome, requests, i18n };
+}
+
+function confirm() {
+ document.querySelector<HTMLButtonElement>("[data-type-management-confirm]")!.click();
+}
+function button(text: string) {
+ return [...document.querySelectorAll<HTMLButtonElement>("button")].find((button) => button.textContent?.trim() === text)!;
+}
+
+describe("TYPE preview using the real component, planner and stores", () => {
+ it("hides the previous final SQL after editing until the new draft is revalidated", async () => {
+ const { queryStore } = await mount();
+ expect([...document.querySelectorAll("pre")].filter((item) => item.textContent === changed)).toHaveLength(2);
+ const editor = document.querySelector<HTMLTextAreaElement>("[data-source-draft]")!;
+ const revised = changed.replace("RETURN 2", "RETURN 3");
+ editor.value = revised;
+ editor.dispatchEvent(new Event("input", { bubbles: true }));
+ await nextTick();
+ expect(queryStore.tabs[0].typeManagementDraft?.drafts[0].source).toBe(revised);
+ expect(document.querySelector<HTMLButtonElement>("[data-type-management-confirm]")!.disabled).toBe(true);
+ expect([...document.querySelectorAll("pre")].some((item) => item.textContent === changed)).toBe(false);
+ document.querySelector<HTMLButtonElement>("[data-validate]")!.click();
+ await vi.waitFor(() => expect(document.querySelector<HTMLButtonElement>("[data-type-management-confirm]")!.disabled).toBe(false));
+ expect([...document.querySelectorAll("pre")].filter((item) => item.textContent === revised)).toHaveLength(2);
+ expect(mocks.executeConditionalUpdate).not.toHaveBeenCalled();
+ });
+
+ it("retains successful compiler warnings in the durable execution record without classifying VALID as a failed save", async () => {
+ mocks.getOracleTypeManagementSnapshot.mockImplementation(async () => {
+ const value = snapshot();
+ value.objects.find((object) => object.objectType === "TYPE BODY")!.errorsRead = { state: "available", reason: "Compilation warnings:\n1:1 PLW-06009: compiler warning" };
+ return value;
+ });
+ const { queryStore, outcome } = await mount();
+ confirm();
+ expect((await outcome).complete).toBe(true);
+ expect(queryStore.tabs[0].typeManagementDraft?.steps[0].state).toBe("confirmed");
+ expect(queryStore.tabs[0].typeManagementDraft?.steps[0].message).toContain("PLW-06009");
+ expect(JSON.stringify(saved)).toContain("PLW-06009");
+ });
+ it("shows the native Oracle route without adding a manual baseline preparation prerequisite", async () => {
+ mocks.getOracleTypeManagementSnapshot.mockImplementation(async () => {
+ const value = snapshot();
+ value.persistentReferences = [{ owner: "APP", tableName: "DATA", columnName: "VALUE", dataTypeOwner: "APP", dataType: "T" }];
+ return value;
+ });
+ mocks.prepareOracleTypeEvolution.mockImplementation(async (input) => ({ ...input, metadata: "verified native guards", phase: 0, statements: ['ALTER TYPE "APP"."T" ADD ATTRIBUTE (LABEL VARCHAR2(40 BYTE)) CASCADE INCLUDING TABLE DATA;'] }));
+ const { queryStore, i18n } = await mount(false, () => true, undefined, "save-spec", "oracle");
+ expect(document.querySelector("[data-native-type-evolution]")?.textContent).toBe(i18n.global.t("objects.typeManagementNativeEvolution"));
+ expect(document.body.textContent).not.toContain(i18n.global.t("objects.typeDataTitle"));
+ expect(queryStore.tabs[0].typeManagementDraft?.nativeEvolution?.phase).toBe(0);
+ expect(queryStore.tabs[0].typeManagementDraft?.issues).toEqual([]);
+ expect(mocks.verifyOracleTypeData).not.toHaveBeenCalled();
+ expect(mocks.executeConditionalUpdate).not.toHaveBeenCalled();
+ });
+ it("shows a different live definition read-only and never offers a blind resend", async () => {
+ failure = "different";
+ const { queryStore, i18n } = await mount();
+ confirm();
+ await vi.waitFor(() => expect(queryStore.tabs[0].typeManagementDraft?.steps[0].state).toBe("unknown"));
+ expect(document.querySelector("[data-current-source] pre")?.textContent).toBe(actualBody);
+ expect(document.querySelector("[data-current-source]")?.textContent).toContain(i18n.global.t("objects.typeManagementCurrentSource"));
+ document.querySelector<HTMLButtonElement>("[data-validate]")!.click();
+ await vi.waitFor(() => expect(queryStore.tabs[0].typeManagementDraft?.issues.some((issue) => issue.code === "unknown-result")).toBe(true));
+ expect(document.querySelector<HTMLButtonElement>("[data-type-management-confirm]")!.disabled).toBe(true);
+ expect(mocks.executeConditionalUpdate).toHaveBeenCalledOnce();
+ });
+ it("does not impose a scalar data migration on a BODY-only save even when the TYPE has stored values", async () => {
+ mocks.getOracleTypeManagementSnapshot.mockImplementation(async () => {
+ const value = snapshot();
+ value.persistentReferences = [{ owner: "APP", tableName: "DATA", columnName: "VALUE", dataTypeOwner: "APP", dataType: "T" }];
+ return value;
+ });
+ const { outcome, i18n } = await mount();
+ expect(document.body.textContent).not.toContain(i18n.global.t("objects.typeDataTitle"));
+ expect(document.querySelector<HTMLButtonElement>("[data-type-management-confirm]")!.disabled).toBe(false);
+ confirm();
+ expect((await outcome).complete).toBe(true);
+ expect(mocks.executeConditionalUpdate).toHaveBeenCalledOnce();
+ expect(mocks.verifyOracleTypeData).not.toHaveBeenCalled();
+ });
+ it("persists a complete manual mapping, keeps SQL-editor preparation separate, and revalidates after actual data and unlink verification", async () => {
+ let prepared = false;
+ mocks.getOracleTypeManagementSnapshot.mockImplementation(async () => {
+ const value = snapshot();
+ value.objects.push({
+ owner: "APP",
+ name: "SRC",
+ objectType: "TABLE",
+ exists: !prepared,
+ objectId: prepared ? null : "table-id",
+ status: prepared ? null : "VALID",
+ statusRead: read,
+ source: null,
+ sourceRead: { state: "unsupported" },
+ errors: [],
+ errorsRead: read,
+ directPrivileges: [],
+ privilegesRead: { state: "unsupported" },
+ });
+ if (!prepared) {
+ value.persistentReferences = [{ owner: "APP", tableName: "SRC", columnName: "VALUE", dataTypeOwner: "APP", dataType: "T" }];
+ value.dependencies = [{ owner: "APP", name: "SRC", objectType: "TABLE", referencedOwner: "APP", referencedName: "T", referencedType: "TYPE" }];
+ }
+ return value;
+ });
+ const projection = [
+ { path: ["VALUE"], objectNull: true, dataType: "NUMBER(1,0)" },
+ { path: ["VALUE", "ID"], objectNull: false, dataType: "NUMBER(38,0)" },
+ ];
+ const baseline = (name: string, original = false) => ({
+ relation: {
+ relation: { owner: "APP", name },
+ objectId: name === "SRC" ? "table-id" : `${name}-id`,
+ readOnly: name === "OLD" || name === "EXPECTED",
+ structure: `${name}-definition`,
+ projection: original
+ ? projection
+ : [
+ { path: ["C1"], objectNull: false, dataType: "NUMBER(1,0)" },
+ { path: ["C2"], objectNull: false, dataType: "NUMBER(38,0)" },
+ ],
+ },
+ rowCount: 3,
+ fingerprint: "c".repeat(64),
+ });
+ mocks.verifyOracleTypeData.mockImplementation(async (input) => {
+ if (input.action === "describe") return { relation: baseline("SRC", true).relation };
+ if (input.action === "register") return { manifest: { mapping: clone(input.mapping), original: baseline("SRC", true), old: baseline("OLD"), expected: baseline("EXPECTED"), preparedTarget: null, verifiedTarget: null } };
+ if (!prepared) throw new Error("Target data and live TYPE references are not ready");
+ return { manifest: { ...clone(input.manifest), verifiedTarget: baseline("RESULT") } };
+ });
+ const { queryStore, outcome, i18n } = await mount(false, () => true, undefined, "save-spec");
+ expect(document.querySelector<HTMLButtonElement>("[data-type-management-confirm]")!.disabled).toBe(true);
+ button(i18n.global.t("objects.typeDataReadProjection")).click();
+ const carrier = () => queryStore.tabs.find((tab) => tab.typeManagementDraft)!;
+ await vi.waitFor(() => expect(carrier().typeManagementDraft?.dataPreparation?.fields).toHaveLength(2));
+ const change = async (input: HTMLInputElement, value: string, expected: () => unknown, wanted: unknown) => {
+ input.value = value;
+ input.dispatchEvent(new Event("input", { bubbles: true }));
+ input.dispatchEvent(new Event("change", { bubbles: true }));
+ await vi.waitFor(() => expect(expected()).toEqual(wanted));
+ };
+ for (const [index, name] of [
+ [0, "OLD"],
+ [1, "EXPECTED"],
+ [2, "RESULT"],
+ ] as const) {
+ const input = document.querySelectorAll("fieldset")[index].querySelectorAll<HTMLInputElement>("input")[1];
+ await change(input, name, () => carrier().typeManagementDraft?.dataPreparation?.[index === 0 ? "old" : index === 1 ? "expected" : "target"].name, name);
+ }
+ const pathLabel = i18n.global.t("objects.typeDataTargetPath");
+ for (const index of [0, 1]) await change(document.querySelector<HTMLInputElement>(`input[aria-label='${pathLabel} ${index + 1}']`)!, JSON.stringify([`C${index + 1}`]), () => carrier().typeManagementDraft?.dataTargetPaths?.[index], JSON.stringify([`C${index + 1}`]));
+ const flag = document.querySelector<HTMLInputElement>(`input[aria-label='${pathLabel} 1 IS NULL']`)!;
+ flag.checked = false;
+ flag.dispatchEvent(new Event("change", { bubbles: true }));
+ await vi.waitFor(() => expect(carrier().typeManagementDraft?.dataPreparation?.fields[0].targetObjectNull).toBe(false));
+ button(i18n.global.t("objects.typeDataPrepareSql")).click();
+ expect(queryStore.tabs.some((tab) => tab.sql.includes('CASE WHEN T."VALUE" IS NULL THEN 1 ELSE 0 END'))).toBe(true);
+ expect(mocks.executeConditionalUpdate).not.toHaveBeenCalled();
+ button(i18n.global.t("objects.typeDataRegister")).click();
+ await vi.waitFor(() => expect(carrier().typeManagementDraft?.dataMappings).toHaveLength(1));
+ const registered = clone(carrier().typeManagementDraft!.dataMappings[0].manifest);
+ expect((saved.tabs.find((tab: any) => tab.typeManagementDraft) as any).typeManagementDraft.dataMappings[0].manifest).toEqual(registered);
+ expect(registered.mapping.fields[0].targetPath).toEqual(["C1"]);
+ button(i18n.global.t("objects.typeDataVerify")).click();
+ await vi.waitFor(() => expect(document.body.textContent).toContain("Target data and live TYPE references are not ready"));
+ expect(carrier().typeManagementDraft!.dataMappings[0].manifest.old).toEqual(registered.old);
+ prepared = true;
+ button(i18n.global.t("objects.typeDataVerify")).click();
+ await vi.waitFor(() => expect(carrier().typeManagementDraft?.dataMappings[0].manifest.verifiedTarget?.rowCount).toBe(3));
+ document.querySelector<HTMLButtonElement>("[data-validate]")!.click();
+ await vi.waitFor(() => expect(carrier().typeManagementDraft?.executable).toBe(true));
+ expect(carrier().typeManagementDraft!.dataMappings[0].manifest.old).toEqual(registered.old);
+ expect(mocks.executeConditionalUpdate).not.toHaveBeenCalled();
+ button(i18n.global.t("objects.typeManagementKeepDraft")).click();
+ expect((await outcome).complete).toBe(false);
+ expect(carrier().typeManagementDraft?.dataMappings[0].manifest.old).toEqual(registered.old);
+ });
+ it("keeps the source draft durable on cancel and sends no SQL merely for preparing a preview", async () => {
+ const { queryStore, outcome, i18n } = await mount();
+ expect(mocks.executeConditionalUpdate).not.toHaveBeenCalled();
+ expect(queryStore.tabs[0].typeManagementDraft?.drafts[0].source).toBe(changed);
+ expect(document.body.textContent).toContain("TYPE BODY");
+ button(i18n.global.t("objects.typeManagementKeepDraft")).click();
+ expect((await outcome).complete).toBe(false);
+ expect(queryStore.tabs[0].typeManagementDraft?.state).toBe("validated");
+ expect((saved.tabs[0] as { typeManagementDraft: { planId: string } }).typeManagementDraft.planId).toBe(queryStore.tabs[0].typeManagementDraft?.planId);
+ });
+
+ it("writes, reads back, and only then marks a BODY save complete", async () => {
+ const { queryStore, outcome } = await mount();
+ confirm();
+ expect((await outcome).complete).toBe(true);
+ expect(mocks.executeConditionalUpdate).toHaveBeenCalledOnce();
+ expect(mocks.executeConditionalUpdate.mock.calls[0].slice(0, 4)).toEqual([target.connectionId, target.database, changed, "APP"]);
+ expect(actualBody).toBe(changed);
+ expect(queryStore.tabs[0].typeManagementDraft?.steps[0].state).toBe("confirmed");
+ expect(queryStore.tabs[0].typeManagementDraft?.state).toBe("complete");
+ expect(queryStore.tabs[0].typeSourceEditing).toBe(false);
+ });
+
+ it("reloads a completed recovery tab so its source identity allows the next explicit edit", async () => {
+ const { queryStore, outcome } = await mount();
+ const tab = queryStore.tabs[0];
+ const { assertSourceIdentity } = await import("@/lib/table/objectSourceIdentity");
+ expect(tab.sourceLoad).toBeUndefined();
+ const originalIdentity = queryStore.getObjectSourceIdentitySnapshot(tab)!;
+ confirm();
+ expect((await outcome).complete).toBe(true);
+ await vi.waitFor(() => expect(() => assertSourceIdentity(queryStore.getObjectSourceIdentitySnapshot(tab)!)).not.toThrow());
+ expect(mocks.getObjectSource).toHaveBeenCalledWith(target.connectionId, target.database, target.owner, target.name, "TYPE_BODY", undefined, undefined);
+ expect(tab.sql).toBe(changed);
+ expect(tab.originalSql).toBe(changed);
+ expect(tab.typeSourceEditing).toBe(false);
+ expect(() => assertSourceIdentity(originalIdentity)).toThrow();
+ expect(mocks.executeConditionalUpdate).toHaveBeenCalledOnce();
+ });
+
+ it.each([false, true])("refreshes the completed recovery tab without handing it to another frozen source tab (dirty=%s)", async (dirty) => {
+ const { queryStore, outcome } = await mount();
+ const recovery = queryStore.tabs[0];
+ const sourceId = queryStore.createTab(target.connectionId, target.database, "Source - T", "query", target.owner, body, undefined, { forceNew: true, sourceView: true });
+ queryStore.setObjectSource(sourceId, { schema: target.owner, name: target.name, objectType: "TYPE_BODY" });
+ const source = queryStore.tabs.find((tab) => tab.id === sourceId)!;
+ const oldDraft = dirty ? `${body}\n-- unsaved source draft` : body;
+ queryStore.updateSql(sourceId, oldDraft);
+ const { assertSourceIdentity } = await import("@/lib/table/objectSourceIdentity");
+ const sourceIdentity = queryStore.getObjectSourceIdentitySnapshot(source)!;
+ confirm();
+ expect((await outcome).complete).toBe(true);
+ await vi.waitFor(() => expect(recovery.sourceLoad).toBeUndefined());
+ expect(queryStore.tabs.map((tab) => tab.id)).toEqual([recovery.id, sourceId]);
+ expect(recovery.typeManagementDraft?.state).toBe("complete");
+ expect(recovery.sql).toBe(changed);
+ expect(recovery.originalSql).toBe(changed);
+ expect(recovery.typeSourceEditing).toBe(false);
+ expect(() => assertSourceIdentity(queryStore.getObjectSourceIdentitySnapshot(recovery)!)).not.toThrow();
+ expect(source.sql).toBe(oldDraft);
+ expect(queryStore.isTabDirty(source)).toBe(dirty);
+ expect(() => assertSourceIdentity(sourceIdentity)).toThrow();
+ expect(mocks.executeConditionalUpdate).toHaveBeenCalledOnce();
+ });
+
+ it("honors the actual production guard's cancellation and target recheck", async () => {
+ let current = true;
+ const { queryStore, outcome, i18n } = await mount(true, () => current);
+ const { useProductionSafetyStore } = await import("@/stores/productionSafetyStore");
+ const safety = useProductionSafetyStore();
+ confirm();
+ await vi.waitFor(() => expect(safety.pending).toBeDefined());
+ safety.cancel();
+ await vi.waitFor(() => expect(document.querySelector<HTMLButtonElement>("[data-type-management-confirm]")!.disabled).toBe(false));
+ expect(mocks.executeConditionalUpdate).not.toHaveBeenCalled();
+ expect(queryStore.tabs[0].typeManagementDraft?.state).toBe("validated");
+ confirm();
+ await vi.waitFor(() => expect(safety.pending).toBeDefined());
+ current = false;
+ safety.confirm();
+ await vi.waitFor(() => expect(document.querySelector<HTMLButtonElement>("[data-type-management-confirm]")!.disabled).toBe(false));
+ expect(mocks.executeConditionalUpdate).not.toHaveBeenCalled();
+ button(i18n.global.t("objects.typeManagementKeepDraft")).click();
+ expect((await outcome).complete).toBe(false);
+ });
+
+ it.each(["invalid", "invalid-response-lost"] as const)("keeps %s with zero diagnostics editable and saves the repaired per-object draft", async (outcomeFailure) => {
+ failure = outcomeFailure;
+ const { queryStore, outcome, i18n } = await mount();
+ confirm();
+ await vi.waitFor(() => expect(document.body.textContent).toContain("INVALID"));
+ await vi.waitFor(() => expect(document.querySelector<HTMLTextAreaElement>("[data-source-draft]")!.disabled).toBe(false));
+ const editor = document.querySelector<HTMLTextAreaElement>("[data-source-draft]")!;
+ expect(editor.labels?.[0]?.textContent).toContain(`${i18n.global.t("objects.typeManagementDraftLabel")} · APP.T`);
+ expect(document.body.textContent).toContain(i18n.global.t("objects.typeManagementValidationPending"));
+ expect(document.body.textContent).not.toContain(i18n.global.t("objects.viewRenameValidationPending"));
+ const repaired = changed.replace("RETURN 2", "RETURN 3");
+ editor.value = repaired;
+ editor.dispatchEvent(new Event("input", { bubbles: true }));
+ await nextTick();
+ expect(document.querySelector<HTMLButtonElement>("[data-type-management-confirm]")!.disabled).toBe(true);
+ failure = undefined;
+ document.querySelector<HTMLButtonElement>("[data-validate]")!.click();
+ await vi.waitFor(() => expect(document.querySelector<HTMLButtonElement>("[data-type-management-confirm]")!.disabled).toBe(false));
+ expect(document.querySelector("[data-type-execution-history]")?.textContent).toContain("INVALID");
+ confirm();
+ expect((await outcome).complete).toBe(true);
+ expect(mocks.executeConditionalUpdate).toHaveBeenCalledTimes(2);
+ expect(actualBody).toBe(repaired);
+ expect(queryStore.tabs[0].sql).toBe(repaired);
+ expect(queryStore.tabs[0].typeManagementDraft?.history[0].state).toBe("failed");
+ });
+
+ it("renders separate diagnostics for actual retries of the same SQL without adding attempts for validation alone", async () => {
+ failure = "invalid";
+ const { queryStore, outcome, i18n } = await mount();
+ confirm();
+ await vi.waitFor(() => expect(queryStore.tabs[0].typeManagementDraft?.steps[0].state).toBe("failed"));
+ document.querySelector<HTMLButtonElement>("[data-validate]")!.click();
+ await vi.waitFor(() => expect(queryStore.tabs[0].typeManagementDraft?.history).toHaveLength(1));
+ await vi.waitFor(() => expect(document.querySelector<HTMLButtonElement>("[data-type-management-confirm]")!.disabled).toBe(false));
+ confirm();
+ await vi.waitFor(() => expect(queryStore.tabs[0].typeManagementDraft?.steps[0].state).toBe("failed"));
+ document.querySelector<HTMLButtonElement>("[data-validate]")!.click();
+ await vi.waitFor(() => expect(queryStore.tabs[0].typeManagementDraft?.history).toHaveLength(2));
+ expect(document.querySelectorAll("[data-type-execution-history] > div")).toHaveLength(2);
+ document.querySelector<HTMLButtonElement>("[data-validate]")!.click();
+ await vi.waitFor(() => expect(document.querySelector<HTMLButtonElement>("[data-type-management-confirm]")!.disabled).toBe(false));
+ expect(queryStore.tabs[0].typeManagementDraft?.history).toHaveLength(2);
+ expect(mocks.executeConditionalUpdate).toHaveBeenCalledTimes(2);
+ button(i18n.global.t("objects.typeManagementKeepDraft")).click();
+ expect((await outcome).complete).toBe(false);
+ });
+
+ it("offers readback after an unknown result without replaying the statement", async () => {
+ failure = "unknown";
+ const { queryStore, outcome, i18n } = await mount();
+ confirm();
+ await vi.waitFor(() => expect(queryStore.tabs[0].typeManagementDraft?.steps[0].state).toBe("unknown"));
+ await vi.waitFor(() => expect(document.querySelector<HTMLButtonElement>("[data-validate]")!.disabled).toBe(false));
+ document.querySelector<HTMLButtonElement>("[data-validate]")!.click();
+ await vi.waitFor(() => expect(document.body.textContent).toContain("previously sent"));
+ expect(mocks.executeConditionalUpdate).toHaveBeenCalledOnce();
+ expect(document.querySelector<HTMLButtonElement>("[data-type-management-confirm]")!.disabled).toBe(true);
+ button(i18n.global.t("objects.typeManagementKeepDraft")).click();
+ expect((await outcome).complete).toBe(false);
+ expect(queryStore.tabs[0].typeManagementDraft?.steps[0].state).toBe("unknown");
+ });
+
+ it("shows the live original and requires revalidation when source changed after the editor loaded", async () => {
+ const { outcome, i18n } = await mount(false, () => true, body.replace("RETURN 1", "RETURN 0"));
+ expect(document.querySelector<HTMLButtonElement>("[data-type-management-confirm]")!.disabled).toBe(true);
+ expect(document.body.textContent).toContain("changed since it was loaded");
+ expect(document.body.textContent).toContain(body);
+ expect(mocks.executeConditionalUpdate).not.toHaveBeenCalled();
+ document.querySelector<HTMLButtonElement>("[data-validate]")!.click();
+ await vi.waitFor(() => expect(document.querySelector<HTMLButtonElement>("[data-type-management-confirm]")!.disabled).toBe(false));
+ button(i18n.global.t("objects.typeManagementKeepDraft")).click();
+ expect((await outcome).complete).toBe(false);
+ });
+});
diff --git a/apps/desktop/src/components/sidebar/ConnectionTree.vue b/apps/desktop/src/components/sidebar/ConnectionTree.vue
index cbcbba67a7..0c0dc66890 100644
--- a/apps/desktop/src/components/sidebar/ConnectionTree.vue
+++ b/apps/desktop/src/components/sidebar/ConnectionTree.vue
@@ -810,7 +810,7 @@ const sidebarTreeLeadingWidthItems = computed(() =>
if (["database", "redis-db", "mongo-db"].includes(node.type) && node.connectionId && typeof node.database === "string" && store.isDefaultDatabase(node.connectionId, node.database)) badges.push(t("editor.defaultDatabase"));
if (node.type === "schema" && node.connectionId && node.schema && store.isDefaultSchema(node.connectionId, node.schema)) badges.push(t("editor.defaultSchema"));
if (showSidebarRowProductionBadge(node, config) && isSidebarProductionContainer(node)) badges.push("PROD");
- const secondary = sidebarTreeSecondaryValue(node, t);
+ const secondary = sidebarTreeSecondaryValue(node, t, config ? effectiveDatabaseTypeForConnection(config) : undefined);
const leadingExtraWidth = (secondary && node.type === "elasticsearch-index" ? 16 : 0) + (node.type === "oracle-db-links" ? 26 : 0);
return { id, depth, node, label: sidebarCommentLabel(node), badges, secondary, leadingExtraWidth };
}),
diff --git a/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue b/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue
index 8342474130..469faabc87 100644
--- a/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue
+++ b/apps/desktop/src/components/sidebar/SidebarTreeRuntimeHost.vue
@@ -162,8 +162,9 @@ import {
treeNodeRowAction,
treeNodeRowDoubleClickAction,
} from "@/lib/sidebar/treeNodeClick";
+import { customTypeCapabilities, supportsOracleFamilyTypeManagement, supportsOracleTypeAttributeExpansion, supportsTypeObjectSource, supportsSchemaIndexManagement } from "@/lib/database/databaseObjectCapabilities";
+import { requestOracleTypeManagement } from "@/lib/table/oracleTypeManagementRequest";
import { qualifiedNameForSidebarNode } from "@/lib/sidebar/sidebarTableNameCopy";
-import { customTypeCapabilities, supportsTypeObjectSource, supportsSchemaIndexManagement } from "@/lib/database/databaseObjectCapabilities";
import { schemaIndexIsSameOwner, schemaIndexNodeIdentity } from "@/lib/table/schemaIndexNavigation";
import { mongoCollectionTableTypeFromNode, mongoCreateDatabasePreview, mongoDropIndexFailureCount } from "@/lib/sidebar/mongoCollectionMutation";
import { dataTabOpenModeFromTreeClick, type DataTabOpenMode } from "@/lib/sidebar/dataTabOpenPolicy";
@@ -955,7 +956,7 @@ async function toggle(requestId = beginNavigationRequest()) {
return;
}
- if (node.type === "type" && customTypeCapabilities(currentDatabaseType()).details && node.children !== undefined) {
+ if (node.type === "type" && customTypeCapabilities(currentDatabaseType()).details && node.children !== undefined && node.hasMembers !== undefined) {
node.isExpanded = node.children.length > 0 ? !node.isExpanded : false;
if (!node.isExpanded) collapseSubtreeDescendants(node);
emitNodeToggled(node, wasExpanded);
@@ -3053,8 +3054,8 @@ function openObjectSourceDialog(initialEditing: boolean, viewPackageBody = false
if (!node.connectionId || !node.database) return;
if (viewPackageBody && (node.type !== "package" || node.xuguPackageBodyAvailable !== true || currentDatabaseType() !== "xugu")) return;
const sourceNode: TreeNode = viewPackageBody ? { ...node, type: "package-body" } : node;
- // TYPE/TYPE_BODY only have a source implementation on Xugu; PostgreSQL-family
- // connections list user-defined types without a CREATE TYPE getter this cycle.
+ // TYPE/TYPE_BODY source is available for Oracle-family databases and Xugu;
+ // PostgreSQL-family connections list user-defined types without a getter.
if ((sourceNode.type === "type" || sourceNode.type === "type-body") && !supportsTypeObjectSource(currentDatabaseType())) return;
const connectionId = node.connectionId;
const database = node.database;
@@ -3285,10 +3286,51 @@ function triggerToggleMenuItems(node: TreeNode): ContextMenuItem[] {
}
function requestDropObject() {
+ if (isManagedTypeNode(activeNode.value)) {
+ void manageTypeDropNode(activeNode.value);
+ return;
+ }
void refreshDropObjectPreviewSql();
showDropObjectConfirm.value = true;
}
+function isManagedTypeNode(node: TreeNode) {
+ return (node.type === "type" || node.type === "type-body") && supportsOracleFamilyTypeManagement(databaseTypeForNode(node));
+}
+
+async function manageTypeDropNode(node: TreeNode): Promise<boolean> {
+ if (!node.connectionId || !node.database || !isManagedTypeNode(node)) return false;
+ const connectionId = node.connectionId,
+ database = node.database,
+ owner = node.schema || database,
+ name = node.objectName || node.label;
+ const databaseType = databaseTypeForNode(node) as "oracle" | "oceanbase-oracle" | "dameng";
+ const activeId = activeNode.value.id;
+ try {
+ const result = await requestOracleTypeManagement({
+ target: { connectionId, database, owner, name, databaseType },
+ operation: node.type === "type-body" ? "delete-body" : "delete-spec",
+ isCurrent: () => activeNode.value.id === activeId && databaseTypeForNode(node) === databaseType && !!connectionStore.getConfig(connectionId),
+ });
+ if (!result.complete) return false;
+ const removed: TreeNode[] = [node];
+ const visit = (nodes: TreeNode[]) => {
+ for (const item of nodes) {
+ if (item.connectionId === connectionId && item.database === database && (item.schema || database) === owner && (item.objectName || item.label) === name && (item.type === node.type || (node.type === "type" && item.type === "type-body"))) removed.push(item);
+ if (item.children) visit(item.children);
+ }
+ };
+ visit(connectionStore.treeNodes);
+ connectionStore.removePinnedTreeNodes(removed);
+ for (const item of removed) connectionStore.removeTreeNode(item.id);
+ releaseActiveNodeReference(removed.map((item) => item.id));
+ return true;
+ } catch (error) {
+ toast(t("contextMenu.tableOperationFailed", { message: String(error) }), 5000);
+ return false;
+ }
+}
+
function requestDropTableChildObject() {
if (isSchemaIndexNode(activeNode.value)) {
requestSchemaIndexDelete(activeNode.value);
@@ -3302,6 +3344,7 @@ function requestDropTableChildObject() {
function canDropTreeNode(node: TreeNode): boolean {
if (["neo4j", "nebula"].includes(databaseTypeForNode(node) || "")) return false;
if (isSqlServerLinkedNode(node)) return false;
+ if (isManagedTypeNode(node)) return !!node.connectionId && !!node.database;
if (node.type === "table") return !!node.connectionId && !!node.database;
if (node.type === "view" || node.type === "materialized_view" || node.type === "procedure" || node.type === "function" || node.type === "event") {
return !!node.connectionId && !!node.database && !!dropObjectSqlOptionsForNode(node);
@@ -3441,6 +3484,7 @@ function batchTruncateConfirmMessage(): string {
}
async function dropSqlForTreeNode(node: TreeNode, options?: { cascade?: boolean }): Promise<string | null> {
+ if (isManagedTypeNode(node)) throw new Error(t("objects.typeManagementUseSave"));
if (node.type === "table" && node.connectionId && node.database) {
const config = connectionStore.getConfig(node.connectionId);
return buildDropTableSql({
@@ -3523,6 +3567,23 @@ function requestBatchDrop() {
}
const targets = selectedBatchDropTargets();
if (!targets.length) return;
+ const managed = targets.filter(isManagedTypeNode);
+ if (managed.length) {
+ void (async () => {
+ const unique = managed.filter(
+ (node) => node.type !== "type-body" || !managed.some((other) => other.type === "type" && other.connectionId === node.connectionId && other.database === node.database && other.schema === node.schema && (other.objectName || other.label) === (node.objectName || node.label)),
+ );
+ for (const node of unique) if (!(await manageTypeDropNode(node))) return;
+ const remaining = targets.filter((node) => !managed.includes(node));
+ if (!remaining.length) return;
+ batchDropTargets.value = remaining;
+ batchDropCascade.value = false;
+ batchDropProgress.value = { completed: 0, total: 0 };
+ await refreshBatchDropPreviewSql();
+ showBatchDropConfirm.value = true;
+ })().catch((error) => toast(t("contextMenu.tableOperationFailed", { message: String(error) }), 5000));
+ return;
+ }
batchDropTargets.value = targets.slice();
batchDropCascade.value = false;
batchDropProgress.value = { completed: 0, total: 0 };
@@ -3657,7 +3718,7 @@ function requestDropSelectedNode(): boolean {
dropTable();
return true;
}
- if (activeNode.value.type === "view" || activeNode.value.type === "procedure" || activeNode.value.type === "function") {
+ if (isManagedTypeNode(activeNode.value) || activeNode.value.type === "view" || activeNode.value.type === "procedure" || activeNode.value.type === "function") {
requestDropObject();
return true;
}
@@ -4336,6 +4397,10 @@ async function confirmRenameObject() {
async function confirmDropObject() {
const node = sidebarDangerTarget.value ?? activeNode.value;
+ if (isManagedTypeNode(node)) {
+ await manageTypeDropNode(node);
+ return;
+ }
if (!node.connectionId || !node.database) return;
const options = dropObjectSqlOptionsForNode(node);
if (!options) return;
@@ -5860,7 +5925,7 @@ function createSidebarObjectTemplate() {
const canExpand = computed(() => {
if (activeNode.value.type === "type" && customTypeCapabilities(currentDatabaseType()).details) {
- return activeNode.value.hasMembers === true;
+ return activeNode.value.hasMembers === true || (activeNode.value.hasMembers === undefined && supportsOracleTypeAttributeExpansion(currentDatabaseType()));
}
return canTreeNodeShowExpander({
type: activeNode.value.type,
@@ -7924,16 +7989,22 @@ function buildObjectSidebarMenu(context: SidebarMenuFactoryContext): boolean {
return true;
}
- // PostgreSQL-family types expand in the tree and expose DDL as a lightweight
- // copy action. Xugu keeps its source/change-open-mode entries.
+ // Oracle-family and Xugu types expose their source; PostgreSQL-family types
+ // keep the existing DDL copy action.
if (node.type === "type" || node.type === "type-body") {
if (supportsTypeObjectSource(currentDatabaseType())) {
items.push({ label: t("contextMenu.viewSource"), action: () => openObjectSourceDialog(false), icon: Code2 });
+ if (supportsOracleFamilyTypeManagement(currentDatabaseType())) {
+ items.push({ label: t("contextMenu.editObject"), action: () => openObjectSourceDialog(true), icon: Pencil });
+ items.push({ label: deleteMenuLabel(t("contextMenu.dropObject")), action: deleteMenuAction(requestDropObject), icon: Trash2, shortcut: shortcutDelete, variant: "destructive" });
+ }
items.push(copyNameMenuItem());
- items.push({ label: t("contextMenu.changeOpenMode"), action: () => emit("open-settings", "navigation"), icon: Settings2 });
+ if (currentDatabaseType() === "xugu") {
+ items.push({ label: t("contextMenu.changeOpenMode"), action: () => emit("open-settings", "navigation"), icon: Settings2 });
+ }
return true;
}
- if (customTypeCapabilities(currentDatabaseType()).details) {
+ if (customTypeCapabilities(currentDatabaseType()).ddl) {
items.push({ label: t("contextMenu.copyDdl"), action: copyCustomTypeDdl, icon: Copy });
items.push({ label: "", separator: true });
}
diff --git a/apps/desktop/src/components/sidebar/TreeItem.vue b/apps/desktop/src/components/sidebar/TreeItem.vue
index 3bcd000baa..a949606d61 100644
--- a/apps/desktop/src/components/sidebar/TreeItem.vue
+++ b/apps/desktop/src/components/sidebar/TreeItem.vue
@@ -118,8 +118,8 @@ import { xuguDatafileDetailRows, xuguTablespaceDetailRows } from "@/lib/sidebar/
import { useDragSort } from "@/composables/useDragSort";
import { sidebarTreeRuntimeKey } from "@/lib/sidebar/sidebarTreeRuntime";
import { treeNodePinKey } from "@/lib/app/pinnedItems";
+import { customTypeCapabilities, supportsOracleTypeAttributeExpansion } from "@/lib/database/databaseObjectCapabilities";
import { sidebarTreeDisplayLabel, sidebarTreeSecondaryValue } from "@/lib/sidebar/sidebarTreeLabel";
-import { customTypeCapabilities } from "@/lib/database/databaseObjectCapabilities";
import { shouldActivateTreeNodeOnSingleClick } from "@/lib/sidebar/treeNodeClick";
const { t } = useI18n();
@@ -465,7 +465,7 @@ function displayLabel(node: TreeNode): string {
}
function treeNodeSecondaryValue(node: TreeNode): string | undefined {
- return sidebarTreeSecondaryValue(node, t);
+ return sidebarTreeSecondaryValue(node, t, node.connectionId ? effectiveDatabaseTypeForConnection(connectionStore.getConfig(node.connectionId)) : undefined);
}
function visibleLabel(node: TreeNode): string {
@@ -772,7 +772,7 @@ const canExpand = computed(() => {
// loadable members; types without members (enum/domain/range/base) do not
// expand even if the catalog row lists child metadata.
if (activeNode.value.type === "type" && customTypeCapabilities(currentDatabaseType()).details) {
- return activeNode.value.hasMembers === true;
+ return activeNode.value.hasMembers === true || (activeNode.value.hasMembers === undefined && supportsOracleTypeAttributeExpansion(currentDatabaseType()));
}
return canTreeNodeShowExpander({
type: activeNode.value.type,
diff --git a/apps/desktop/src/components/sidebar/__tests__/SidebarTreeRuntimeHost.expansion.spec.ts b/apps/desktop/src/components/sidebar/__tests__/SidebarTreeRuntimeHost.expansion.spec.ts
index 09b7df959e..d28dcb7de3 100644
--- a/apps/desktop/src/components/sidebar/__tests__/SidebarTreeRuntimeHost.expansion.spec.ts
+++ b/apps/desktop/src/components/sidebar/__tests__/SidebarTreeRuntimeHost.expansion.spec.ts
@@ -28,6 +28,11 @@ const connectionStore = {
node.isExpanded = true;
}),
loadTables: vi.fn(async () => undefined),
+ loadCustomTypeChildren: vi.fn(async (node: TreeNode) => {
+ node.hasMembers = true;
+ node.children = [{ id: `${node.id}:attribute`, label: "STREET", type: "type-member", connectionId: node.connectionId, database: node.database }];
+ node.isExpanded = true;
+ }),
loadXuguTablespaces: vi.fn(async (node: TreeNode) => {
node.isExpanded = true;
}),
@@ -99,9 +104,62 @@ afterEach(() => {
connectionStore.getConfig.mockReturnValue({ db_type: "mysql", name: "connection" });
connectionStore.getEtcdAccessCapabilities.mockReturnValue({ admin: true, writable: true, writePermissions: null });
connectionStore.loadTables.mockResolvedValue(undefined);
+ connectionStore.loadCustomTypeChildren.mockClear();
});
describe("SidebarTreeRuntimeHost expansion", () => {
+ it.each(["oracle", "oceanbase-oracle", "dameng"] as const)("lazy-loads unknown TYPE members for %s on row activation", async (dbType) => {
+ const typeNode: TreeNode = { id: `${dbType}:demo:APP:TYPE_OBJ`, label: "TYPE_OBJ", type: "type", connectionId: dbType, database: "demo", schema: "APP", objectName: "TYPE_OBJ", hasMembers: undefined };
+ connectionStore.getConfig.mockReturnValue({ db_type: dbType });
+ const host = ref<InstanceType<typeof SidebarTreeRuntimeHost> | null>(null);
+ const app = createApp(defineComponent({ setup: () => () => h(SidebarTreeRuntimeHost, { ref: host, node: typeNode, depth: 0 }) }));
+ mountedApps.push(app);
+ const container = document.createElement("div");
+ document.body.append(container);
+ app.use(i18n);
+ app.mount(container);
+ host.value!.handleRowClick(typeNode, 1);
+ await vi.waitFor(() => expect(connectionStore.loadCustomTypeChildren).toHaveBeenCalledWith(typeNode));
+ expect(typeNode.children?.[0]?.label).toBe("STREET");
+ expect(queryStore.createTab).not.toHaveBeenCalled();
+ });
+
+ it("retries expansion for Oracle TYPE nodes with partial children and unknown member state", async () => {
+ const typeNode: TreeNode = {
+ id: "oracle:XE:APP:TYPE_OBJ",
+ label: "TYPE_OBJ",
+ type: "type",
+ connectionId: "oracle",
+ database: "XE",
+ schema: "APP",
+ hasMembers: undefined,
+ children: [{ id: "oracle:XE:APP:TYPE_OBJ:attribute", label: "STREET", type: "type-member", connectionId: "oracle", database: "XE" }],
+ };
+ connectionStore.getConfig.mockReturnValue({ db_type: "oracle" });
+ connectionStore.loadCustomTypeChildren.mockImplementation(async (node: TreeNode) => {
+ node.hasMembers = undefined;
+ node.children = [{ id: `${node.id}:attribute`, label: "STREET", type: "type-member", connectionId: node.connectionId, database: node.database }];
+ node.isExpanded = true;
+ });
+ const host = ref<InstanceType<typeof SidebarTreeRuntimeHost> | null>(null);
+ const app = createApp(defineComponent({ setup: () => () => h(SidebarTreeRuntimeHost, { ref: host, node: typeNode, depth: 0 }) }));
+ mountedApps.push(app);
+ const container = document.createElement("div");
+ document.body.append(container);
+ app.use(i18n);
+ app.mount(container);
+
+ host.value!.toggleNode(typeNode);
+ await vi.waitFor(() => expect(connectionStore.loadCustomTypeChildren).toHaveBeenCalledTimes(1));
+ expect(typeNode.isExpanded).toBe(true);
+ expect(typeNode.children?.map((child) => child.label)).toEqual(["STREET"]);
+ host.value!.toggleNode(typeNode);
+ expect(typeNode.isExpanded).toBe(false);
+ host.value!.toggleNode(typeNode);
+ await vi.waitFor(() => expect(connectionStore.loadCustomTypeChildren).toHaveBeenCalledTimes(2));
+ expect(typeNode.isExpanded).toBe(true);
+ });
+
it.each(["single", "double"] as const)("focuses object search when %s-click activation opens a database", async (activation) => {
const database: TreeNode = {
id: "mysql:dbx_test",
diff --git a/apps/desktop/src/components/sidebar/__tests__/SidebarTreeRuntimeHost.tableTriggerContextMenu.spec.ts b/apps/desktop/src/components/sidebar/__tests__/SidebarTreeRuntimeHost.tableTriggerContextMenu.spec.ts
index e4eabcd99b..7e94e3ad3f 100644
--- a/apps/desktop/src/components/sidebar/__tests__/SidebarTreeRuntimeHost.tableTriggerContextMenu.spec.ts
+++ b/apps/desktop/src/components/sidebar/__tests__/SidebarTreeRuntimeHost.tableTriggerContextMenu.spec.ts
@@ -1,7 +1,7 @@
// @vitest-environment happy-dom
import { createApp, defineComponent, h, nextTick, ref, type App } from "vue";
import { createPinia, setActivePinia } from "pinia";
-import { afterEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import i18n from "@/i18n";
import type { ContextMenuItem } from "@/components/ui/CustomContextMenu.vue";
import type { DatabaseType, TreeNode } from "@/types/database";
@@ -12,12 +12,20 @@ vi.mock("@/lib/backend/api", async (importOriginal) => {
...actual,
listPlugins: vi.fn().mockResolvedValue([]),
executeQuery: vi.fn().mockResolvedValue({ success: true, columns: [], rows: [] }),
+ checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
+ subscribeConnectionLiveness: vi.fn().mockResolvedValue(() => {}),
+ subscribeConnectionIdleClosed: vi.fn().mockResolvedValue(() => {}),
+ deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
+ loadSchemaCache: vi.fn().mockResolvedValue(null),
};
});
vi.mock("@/lib/common/clipboard", () => ({ copyToClipboard: vi.fn().mockResolvedValue(true) }));
import SidebarTreeRuntimeHost from "@/components/sidebar/SidebarTreeRuntimeHost.vue";
import { useConnectionStore } from "@/stores/connectionStore";
+import { useQueryStore } from "@/stores/queryStore";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { finishOracleTypeManagementRequest, oracleTypeManagementRequest } from "@/lib/table/oracleTypeManagementRequest";
const node = (type: TreeNode["type"], label: string, tableName?: string): TreeNode => ({
id: `test-conn:db:${type}:${label}`,
@@ -29,8 +37,10 @@ const node = (type: TreeNode["type"], label: string, tableName?: string): TreeNo
database: "testdb",
});
const mountedApps: App<Element>[] = [];
+const sourceEvents: Array<{ node: TreeNode; initialEditing: boolean }> = [];
const labels = (items: ContextMenuItem[]): string[] => items.flatMap((item) => [...(item.label ? [item.label] : []), ...(item.children ? labels(item.children) : [])]);
const tr = (key: string) => i18n.global.t(key);
+const unexpectedHttp: string[] = [];
async function mountHost(dbType: DatabaseType = "firebird", treeNodes: TreeNode[] = []) {
const pinia = createPinia();
@@ -38,10 +48,9 @@ async function mountHost(dbType: DatabaseType = "firebird", treeNodes: TreeNode[
const store = useConnectionStore();
store.treeNodes = treeNodes;
store.connections = [{ id: "test-conn", name: "TestDB", db_type: dbType, driver_profile: dbType, host: "localhost", port: 3050, username: "sysdba", password: "masterkey" }];
- vi.spyOn(store, "ensureConnected").mockResolvedValue(undefined as any);
- vi.spyOn(store, "refreshTreeNode").mockResolvedValue(undefined as any);
+ store.connectedIds.add("test-conn");
const host = ref<InstanceType<typeof SidebarTreeRuntimeHost> | null>(null);
- const root = defineComponent({ setup: () => () => h(SidebarTreeRuntimeHost, { ref: host, node: node("connection", "TestDB"), depth: 0 }) });
+ const root = defineComponent({ setup: () => () => h(SidebarTreeRuntimeHost, { ref: host, node: node("connection", "TestDB"), depth: 0, "onOpen-object-source": (sourceNode: TreeNode, initialEditing: boolean) => sourceEvents.push({ node: sourceNode, initialEditing }) }) });
const container = document.createElement("div");
document.body.appendChild(container);
const app = createApp(root);
@@ -52,14 +61,100 @@ async function mountHost(dbType: DatabaseType = "firebird", treeNodes: TreeNode[
await nextTick();
await new Promise((resolve) => setTimeout(resolve, 0));
await nextTick();
- return host.value as { buildContextMenu(node: TreeNode): ContextMenuItem[] };
+ return host.value as { buildContextMenu(node: TreeNode): ContextMenuItem[]; handleRowKeydown(node: TreeNode, event: KeyboardEvent): void };
}
describe("Table trigger context menu", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ unexpectedHttp.length = 0;
+ vi.spyOn(globalThis, "fetch").mockImplementation(async (input) => {
+ unexpectedHttp.push(String(input));
+ throw new Error(`Unexpected HTTP boundary: ${String(input)}`);
+ });
+ });
afterEach(() => {
+ const pending = oracleTypeManagementRequest.value;
+ if (pending) finishOracleTypeManagementRequest(pending.id, { complete: false, target: pending.target, operation: pending.operation });
vi.clearAllMocks();
for (const app of mountedApps.splice(0)) app.unmount();
document.body.innerHTML = "";
+ sourceEvents.length = 0;
+ vi.restoreAllMocks();
+ expect(unexpectedHttp).toEqual([]);
+ });
+
+ it.each(["oracle", "oceanbase-oracle", "dameng"] as const)("routes %s TYPE deletion keys to the exact managed preview without executing SQL", async (databaseType) => {
+ const host = await mountHost(databaseType);
+ const store = useConnectionStore();
+ const api = await import("@/lib/backend/api");
+ for (const type of ["type", "type-body"] as const) {
+ const selected = { ...node(type, "Type' Name"), schema: "App" };
+ store.treeNodes = [selected];
+ store.selectedTreeNodeId = selected.id;
+ store.selectedTreeNodeIds = [selected.id];
+ const event = new KeyboardEvent("keydown", { key: "Delete", bubbles: true, cancelable: true });
+ host.handleRowKeydown(selected, event);
+ await vi.waitFor(() => expect(oracleTypeManagementRequest.value?.operation).toBe(type === "type-body" ? "delete-body" : "delete-spec"));
+ const pending = oracleTypeManagementRequest.value!;
+ expect(pending.target).toEqual({ connectionId: "test-conn", database: "testdb", owner: "App", name: "Type' Name", databaseType });
+ expect(event.defaultPrevented).toBe(true);
+ expect(api.executeQuery).not.toHaveBeenCalled();
+ finishOracleTypeManagementRequest(pending.id, { complete: false, target: pending.target, operation: pending.operation });
+ await nextTick();
+ expect(store.treeNodes[0].id).toBe(selected.id);
+ }
+ });
+
+ it.each(["postgres", "xugu", "mysql"] as const)("does not route TYPE deletion for unsupported %s connections", async (databaseType) => {
+ const host = await mountHost(databaseType);
+ const store = useConnectionStore();
+ for (const type of ["type", "type-body"] as const) {
+ const selected = node(type, "T");
+ store.treeNodes = [selected];
+ store.selectedTreeNodeId = selected.id;
+ store.selectedTreeNodeIds = [selected.id];
+ const event = new KeyboardEvent("keydown", { key: "Delete", cancelable: true });
+ host.handleRowKeydown(selected, event);
+ expect(oracleTypeManagementRequest.value).toBeNull();
+ expect(event.defaultPrevented).toBe(false);
+ }
+ });
+
+ it("opens Oracle-family TYPE and TYPE_BODY query tabs in viewing mode before explicit editing", async () => {
+ for (const dbType of ["oracle", "oceanbase-oracle", "dameng"] as const) {
+ const host = await mountHost(dbType);
+ useSettingsStore().updateEditorSettings({ routineSourceOpenMode: "query-tab" });
+ const pendingSourceTab = vi.spyOn(useQueryStore(), "openObjectSourceTabPending").mockImplementation(() => undefined);
+
+ for (const type of ["type", "type-body"] as const) {
+ const typeNode = node(type, type === "type" ? "TYPE_OBJ" : "TYPE_OBJ_BODY");
+ const menu = host.buildContextMenu(typeNode);
+ expect(labels(menu)).not.toContain(tr("contextMenu.changeOpenMode"));
+ const sourceAction = menu.find((item) => item.label === tr("contextMenu.viewSource"));
+ await sourceAction?.action?.();
+ expect(pendingSourceTab).toHaveBeenLastCalledWith(expect.objectContaining({ connectionId: "test-conn", database: "testdb", request: expect.objectContaining({ name: typeNode.label, objectType: type === "type" ? "TYPE" : "TYPE_BODY" }), initialEditing: false }));
+ }
+ expect(pendingSourceTab).toHaveBeenCalledTimes(2);
+ }
+ expect(sourceEvents).toEqual([]);
+ });
+
+ it("preserves query-tab source routing for Xugu types and routines", async () => {
+ const host = await mountHost("xugu");
+ useSettingsStore().updateEditorSettings({ routineSourceOpenMode: "query-tab" });
+ const queryStore = useQueryStore();
+ const pendingSourceTab = vi.spyOn(queryStore, "openObjectSourceTabPending").mockImplementation(() => undefined);
+
+ const xuguTypeMenu = host.buildContextMenu(node("type", "T_XUGU"));
+ expect(labels(xuguTypeMenu)).toContain(tr("contextMenu.changeOpenMode"));
+ for (const sourceNode of [node("type", "T_XUGU"), node("procedure", "P_XUGU")]) {
+ const sourceAction = host.buildContextMenu(sourceNode).find((item) => item.label === tr("contextMenu.viewSource"));
+ await sourceAction?.action?.();
+ }
+
+ expect(pendingSourceTab).toHaveBeenCalledTimes(2);
+ expect(sourceEvents).toHaveLength(0);
});
it("exposes view source and change open mode for table triggers", async () => {
diff --git a/apps/desktop/src/components/sidebar/__tests__/TreeItem.emptyDatabaseFilter.spec.ts b/apps/desktop/src/components/sidebar/__tests__/TreeItem.emptyDatabaseFilter.spec.ts
index d30104e2c0..4727e8b26b 100644
--- a/apps/desktop/src/components/sidebar/__tests__/TreeItem.emptyDatabaseFilter.spec.ts
+++ b/apps/desktop/src/components/sidebar/__tests__/TreeItem.emptyDatabaseFilter.spec.ts
@@ -18,7 +18,7 @@ const connectionStore = {
connectingIds: new Set<string>(),
connectionMultiSelectActive: false,
connections: [],
- getConfig: () => ({ id: "hana-1", db_type: "saphana" }),
+ getConfig: vi.fn(() => ({ id: "hana-1", db_type: "saphana" })),
isDefaultDatabase: () => false,
isDefaultSchema: () => false,
isPinnedTreeNodeReorderTarget: () => false,
@@ -107,4 +107,23 @@ describe("TreeItem empty database filter badge", () => {
expect(container.textContent).toContain("12");
expect(container.textContent).toContain("filtered");
});
+
+ it.each([
+ ["oracle", "object", "Object type"],
+ ["oracle", "collection", "Collection type"],
+ ["oracle", "other-kind", "Other type"],
+ ["postgres", "enum", "Enum"],
+ ])("renders the %s custom type kind with its existing locale key", async (dbType, kind, expected) => {
+ connectionStore.getConfig.mockReturnValue({ id: "hana-1", db_type: dbType });
+ const container = await mountTreeItem({
+ id: `${dbType}:type`,
+ label: "TYPE_OBJ",
+ type: "type",
+ connectionId: "hana-1",
+ database: "app",
+ customTypeKind: kind,
+ } as TreeNode);
+ expect(container.textContent).toContain(expected);
+ expect(container.textContent).not.toContain(`${dbType === "postgres" ? "oracleType" : "customType"}.kinds`);
+ });
});
diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.ts
index aaed5639d8..b8d7fb1b35 100644
--- a/apps/desktop/src/i18n/locales/en.ts
+++ b/apps/desktop/src/i18n/locales/en.ts
@@ -506,6 +506,43 @@ export default {
incomplete: "The generated DDL is incomplete and was not copied. Open the type details to review its warnings.",
},
},
+ oracleType: {
+ kinds: { object: "Object type", collection: "Collection type", other: "Other type" },
+ source: "Source",
+ bodySource: "Type body source",
+ viewBody: "View type body",
+ methods: "Methods",
+ methodMetadata: "Method metadata",
+ parameters: "Parameters",
+ results: "Results",
+ parameter: "Parameter",
+ result: "Result",
+ emptyMethods: "No methods in the visible dictionary result.",
+ emptyAttributes: "No attributes in the visible dictionary result.",
+ owner: "Owner",
+ status: "Status",
+ typeCode: "Type code",
+ isFinal: "Final",
+ instantiable: "Instantiable",
+ supertype: "Supertype",
+ attributeCount: "Attribute count",
+ methodCount: "Method count",
+ bodyStatus: "Body status",
+ propertiesRead: "Type properties",
+ bodyRead: "Type body pairing",
+ boolean: { yes: "Yes", no: "No" },
+ bodyVisibility: "Type body visibility",
+ bodyVisible: "Type body is visible in the current dictionary scope",
+ bodyNotVisible: "No type body is visible in the current dictionary scope",
+ unknown: "Unknown",
+ body: "Type body",
+ collection: "Collection",
+ upperBound: "Upper bound",
+ length: "Length",
+ precision: "Precision",
+ scale: "Scale",
+ read: { available: "Loaded", incomplete: "Incomplete", unavailable: "Unavailable or not visible", unsupported: "Unsupported" },
+ },
docs,
dataDictionary,
pluginPlatform: {
@@ -6249,6 +6286,57 @@ export default {
saveSource: "Save",
cancelEdit: "Cancel",
sourceSaved: "Source saved",
+ typeManagementTitle: "TYPE changes",
+ typeManagementNonAtomic: "DDL commits step by step. Closing this preview keeps drafts and execution records in the source tab.",
+ typeManagementScope: "Automatic migration covers only dependencies visible to this account. Hidden cross-owner callers may become invalid.",
+ typeManagementDeleteSpec: "Deleting the specification also deletes TYPE BODY. Remove dependent references first; data tables are not deleted automatically.",
+ typeManagementDeleteBody: "Delete only TYPE BODY and keep the specification. Objects calling its methods may become invalid.",
+ typeManagementKeepDraft: "Keep draft",
+ typeManagementConfirm: "Confirm execution",
+ typeManagementStop: "Stop remaining steps",
+ typeManagementResume: "Review / resume changes",
+ typeManagementUseSave: "Use Preview and save for TYPE source; do not execute it directly.",
+ typeManagementPreviewSave: "Preview and save",
+ typeManagementExistingDraft: "This object has an unfinished change. Continuing the original plan.",
+ typeManagementCloseWarning: "Closing these tabs discards their local TYPE recovery records. Applied DDL and database baselines are not undone or deleted.",
+ typeManagementDiscardClose: "Discard recovery record and close",
+ typeManagementDeleted: "Object deleted. Its original definition is kept for reference.",
+ typeManagementRefreshFailed: "Changes were applied, but refresh failed: {message}. Read back the state; do not execute again.",
+ typeManagementRunningClose: "A TYPE statement is still in flight. Stop remaining steps in the preview, then wait for readback before closing.",
+ typeManagementMaintenance: "Business writes to affected objects are paused, and I am ready to verify each applied step.",
+ typeDataTitle: "Persistent data mapping",
+ typeDataInstructions: "Prepare and commit permanent scalar OLD/EXPECTED tables and make them natively read-only. Register the complete original values before conversion or unlinking in the SQL editor. Return to verify data, then revalidate the TYPE plan.",
+ typeDataSource: "Original table / field",
+ typeDataTarget: "Target table",
+ typeDataOwner: "Exact owner",
+ typeDataReadProjection: "Read full projection",
+ typeDataTargetPath: "Target field path (JSON)",
+ typeDataUnchanged: "Keep original value",
+ typeDataPrepareHint: "OLD must retain every protected original value; EXPECTED describes every target value. Unchanged fields are compared in full. Row removal, addition and aggregation are not supported.",
+ typeDataPrepareSql: "Open original projection in SQL editor",
+ typeDataRegister: "Register and save baselines",
+ typeDataVerified: "Complete target data verified. Revalidate to continue TYPE steps.",
+ typeDataWaiting: "Awaiting conversion, complete target verification and removal of TYPE references.",
+ typeDataIntegrity: "Baseline identity and integrity",
+ typeDataBoundedInsert: "Bounded scalar INSERT",
+ typeDataInsertHint: "Only one explicit-column INSERT SELECT from registered EXPECTED to the registered empty scalar table is accepted. Functions, filters, joins and implicit writes are rejected. Prepare complex conversions in the SQL editor, then return for verification.",
+ typeDataPreviewInsert: "Preview and validate INSERT",
+ typeDataRunInsert: "Confirm scalar insertion",
+ typeDataVerify: "Verify original baselines and target",
+ typeDataKeepBaselines: "OLD/EXPECTED and recovery records are retained. Cancellation, failure, closing and success never delete baselines automatically.",
+ typeDataPathError: "The target field path must be a nonempty JSON array of strings.",
+ typeManagementCurrentSource: "Current database source",
+ typeManagementNativeEvolution: "Oracle native evolution preserves data in place; no OLD/EXPECTED preparation is required. Type structure, dependencies and table state are checked at each step.",
+ typeManagementPreviousAttempts: "Previous execution attempts",
+ typeManagementDraftLabel: "Definition to execute",
+ typeManagementValidationPending: "Fix the definition or dependencies, then revalidate. Confirm execution after validation succeeds.",
+ typeManagementState: {
+ "not-sent": "Not sent",
+ sent: "Sent",
+ confirmed: "Verified",
+ failed: "Failed",
+ unknown: "Unknown result",
+ },
sourceSaveFailed: "Failed to save source: {message}",
routineWritePending: "The original request has not been confirmed as finished (operation {operationId}). The draft is preserved; saving again only checks the original request and does not resend it.",
routineWriteUnverified: "The save has not been verified as successful (operation {operationId}). The draft is preserved; handle this according to the result below.",
diff --git a/apps/desktop/src/i18n/locales/es.ts b/apps/desktop/src/i18n/locales/es.ts
index bbd693a4a5..e692cce5b8 100644
--- a/apps/desktop/src/i18n/locales/es.ts
+++ b/apps/desktop/src/i18n/locales/es.ts
@@ -364,6 +364,43 @@ export default withEnglishFallback({
incomplete: "El DDL generado está incompleto y no se copió. Abra los detalles del tipo para revisar las advertencias.",
},
},
+ oracleType: {
+ kinds: { object: "Tipo de objeto", collection: "Tipo colección", other: "Otro tipo" },
+ source: "Código fuente",
+ bodySource: "Código del cuerpo del tipo",
+ viewBody: "Ver cuerpo del tipo",
+ methods: "Métodos",
+ methodMetadata: "Metadatos de métodos",
+ parameters: "Parámetros",
+ results: "Resultados",
+ parameter: "Parámetro",
+ result: "Resultado",
+ emptyMethods: "No hay métodos en el resultado visible del diccionario.",
+ emptyAttributes: "No hay atributos en el resultado visible del diccionario.",
+ owner: "Propietario",
+ status: "Estado",
+ typeCode: "Código de tipo",
+ isFinal: "Final",
+ instantiable: "Instanciable",
+ supertype: "Supertipo",
+ attributeCount: "Número de atributos",
+ methodCount: "Número de métodos",
+ bodyStatus: "Estado del cuerpo",
+ propertiesRead: "Propiedades del tipo",
+ bodyRead: "Lectura del cuerpo del tipo",
+ boolean: { yes: "Sí", no: "No" },
+ bodyVisibility: "Visibilidad del cuerpo del tipo",
+ bodyVisible: "El cuerpo del tipo está visible en el ámbito actual del diccionario",
+ bodyNotVisible: "No hay ningún cuerpo del tipo visible en el ámbito actual del diccionario",
+ unknown: "Desconocido",
+ body: "Cuerpo del tipo",
+ collection: "Colección",
+ upperBound: "Límite superior",
+ length: "Longitud",
+ precision: "Precisión",
+ scale: "Escala",
+ read: { available: "Cargado", incomplete: "Incompleto", unavailable: "No disponible o no visible", unsupported: "No compatible" },
+ },
docs,
dataDictionary,
pluginPlatform: {
@@ -5307,6 +5344,57 @@ export default withEnglishFallback({
saveSource: "Guardar",
cancelEdit: "Cancelar",
sourceSaved: "Código fuente guardado",
+ typeManagementTitle: "Cambios de TYPE",
+ typeManagementNonAtomic: "El DDL se confirma paso a paso. Al cerrar la vista previa, los borradores y registros se conservan en la pestaña del código.",
+ typeManagementScope: "La migración automática solo cubre dependencias visibles para esta cuenta. Los llamadores ocultos de otros propietarios pueden quedar inválidos.",
+ typeManagementDeleteSpec: "Eliminar la especificación también elimina TYPE BODY. Quite primero las referencias dependientes; las tablas de datos no se eliminan automáticamente.",
+ typeManagementDeleteBody: "Eliminar solo TYPE BODY y conservar la especificación. Los objetos que llaman a sus métodos pueden quedar inválidos.",
+ typeManagementKeepDraft: "Conservar borrador",
+ typeManagementConfirm: "Confirmar ejecución",
+ typeManagementStop: "Detener pasos restantes",
+ typeManagementResume: "Revisar / reanudar cambios",
+ typeManagementUseSave: "Use Vista previa y guardar para el código TYPE; no lo ejecute directamente.",
+ typeManagementPreviewSave: "Vista previa y guardar",
+ typeManagementExistingDraft: "Este objeto tiene un cambio pendiente. Se continúa el plan original.",
+ typeManagementCloseWarning: "Cerrar estas pestañas descarta sus registros locales de recuperación de TYPE. No revierte el DDL aplicado ni elimina las tablas de referencia.",
+ typeManagementDiscardClose: "Descartar registro y cerrar",
+ typeManagementDeleted: "Objeto eliminado. Se conserva la definición original como referencia.",
+ typeManagementRefreshFailed: "Los cambios se aplicaron, pero falló la actualización: {message}. Consulte el estado; no los ejecute otra vez.",
+ typeManagementRunningClose: "Hay una sentencia TYPE en curso. Detenga los pasos restantes y espere a la verificación antes de cerrar.",
+ typeManagementMaintenance: "Las escrituras de negocio en los objetos afectados están pausadas y estoy listo para verificar cada paso.",
+ typeDataTitle: "Mapeo de datos persistentes",
+ typeDataInstructions: "Prepare y confirme tablas escalares permanentes OLD/EXPECTED y póngalas en solo lectura nativa. Registre todos los valores originales antes de convertir o quitar referencias en el editor SQL. Verifique los datos y vuelva a validar el plan TYPE.",
+ typeDataSource: "Tabla / campo original",
+ typeDataTarget: "Tabla destino",
+ typeDataOwner: "Propietario exacto",
+ typeDataReadProjection: "Leer proyección completa",
+ typeDataTargetPath: "Ruta destino (JSON)",
+ typeDataUnchanged: "Conservar valor original",
+ typeDataPrepareHint: "OLD debe conservar todos los valores protegidos; EXPECTED describe todos los valores destino. Los campos sin cambios se comparan completos. No se admite agregar o quitar filas ni agregar datos.",
+ typeDataPrepareSql: "Abrir proyección original en SQL",
+ typeDataRegister: "Registrar y guardar bases",
+ typeDataVerified: "Datos destino completos verificados. Valide de nuevo para continuar con TYPE.",
+ typeDataWaiting: "Pendientes la conversión, la verificación completa y la eliminación de referencias TYPE.",
+ typeDataIntegrity: "Identidad e integridad de las bases",
+ typeDataBoundedInsert: "INSERT escalar limitado",
+ typeDataInsertHint: "Solo se admite un INSERT SELECT con columnas explícitas desde EXPECTED registrado a la tabla escalar vacía registrada. Se rechazan funciones, filtros, uniones y escrituras implícitas. Prepare conversiones complejas en el editor SQL y vuelva a verificar.",
+ typeDataPreviewInsert: "Previsualizar y validar INSERT",
+ typeDataRunInsert: "Confirmar inserción escalar",
+ typeDataVerify: "Verificar bases y destino",
+ typeDataKeepBaselines: "Se conservan OLD/EXPECTED y los registros de recuperación. Cancelar, fallar, cerrar o finalizar nunca elimina las bases automáticamente.",
+ typeDataPathError: "La ruta destino debe ser una matriz JSON no vacía de cadenas.",
+ typeManagementCurrentSource: "Código actual en la base de datos",
+ typeManagementNativeEvolution: "La evolución nativa de Oracle conserva los datos sin moverlos; no requiere preparar OLD/EXPECTED. Cada paso verifica la estructura del tipo, las dependencias y el estado de las tablas.",
+ typeManagementPreviousAttempts: "Intentos de ejecución anteriores",
+ typeManagementDraftLabel: "Definición que se ejecutará",
+ typeManagementValidationPending: "Corrige la definición o las dependencias y vuelve a validar. Confirma la ejecución cuando la validación sea correcta.",
+ typeManagementState: {
+ "not-sent": "No enviado",
+ sent: "Enviado",
+ confirmed: "Verificado",
+ failed: "Fallido",
+ unknown: "Resultado desconocido",
+ },
sourceSaveFailed: "Error al guardar el código fuente: {message}",
routineWritePending: "Aún no se ha confirmado que la solicitud original haya terminado (operación {operationId}). Se conserva el borrador; volver a guardar solo comprueba la solicitud original, no la vuelve a enviar.",
routineWriteUnverified: "Aún no se ha verificado que el guardado haya tenido éxito (operación {operationId}). Se conserva el borrador; actúe según el resultado que aparece a continuación.",
diff --git a/apps/desktop/src/i18n/locales/it.ts b/apps/desktop/src/i18n/locales/it.ts
index 349e8c95d8..c43bf450f4 100644
--- a/apps/desktop/src/i18n/locales/it.ts
+++ b/apps/desktop/src/i18n/locales/it.ts
@@ -362,6 +362,43 @@ export default withEnglishFallback({
incomplete: "Il DDL generato è incompleto e non è stato copiato. Apri i dettagli del tipo per controllare gli avvisi.",
},
},
+ oracleType: {
+ kinds: { object: "Tipo oggetto", collection: "Tipo collezione", other: "Altro tipo" },
+ source: "Sorgente",
+ bodySource: "Sorgente del corpo del tipo",
+ viewBody: "Visualizza corpo del tipo",
+ methods: "Metodi",
+ methodMetadata: "Metadati dei metodi",
+ parameters: "Parametri",
+ results: "Risultati",
+ parameter: "Parametro",
+ result: "Risultato",
+ emptyMethods: "Nessun metodo nel risultato visibile del dizionario.",
+ emptyAttributes: "Nessun attributo nel risultato visibile del dizionario.",
+ owner: "Owner",
+ status: "Stato",
+ typeCode: "Codice tipo",
+ isFinal: "Finale",
+ instantiable: "Istanziale",
+ supertype: "Supertipo",
+ attributeCount: "Numero attributi",
+ methodCount: "Numero metodi",
+ bodyStatus: "Stato del corpo",
+ propertiesRead: "Proprietà del tipo",
+ bodyRead: "Lettura del corpo del tipo",
+ boolean: { yes: "Sì", no: "No" },
+ bodyVisibility: "Visibilità del corpo del tipo",
+ bodyVisible: "Il corpo del tipo è visibile nell'ambito corrente del dizionario",
+ bodyNotVisible: "Nessun corpo del tipo è visibile nell'ambito corrente del dizionario",
+ unknown: "Sconosciuto",
+ body: "Corpo del tipo",
+ collection: "Collezione",
+ upperBound: "Limite superiore",
+ length: "Lunghezza",
+ precision: "Precisione",
+ scale: "Scala",
+ read: { available: "Caricato", incomplete: "Incompleto", unavailable: "Non disponibile o non visibile", unsupported: "Non supportato" },
+ },
docs,
dataDictionary,
pluginPlatform: {
@@ -5127,6 +5164,57 @@ export default withEnglishFallback({
saveSource: "Salva",
cancelEdit: "Annulla",
sourceSaved: "Sorgente salvato",
+ typeManagementTitle: "Modifiche TYPE",
+ typeManagementNonAtomic: "Il DDL viene confermato passo per passo. Chiudendo l’anteprima, bozze e registri restano nella scheda del sorgente.",
+ typeManagementScope: "La migrazione automatica copre solo le dipendenze visibili a questo account. I chiamanti nascosti di altri proprietari possono diventare non validi.",
+ typeManagementDeleteSpec: "Eliminando la specifica si elimina anche TYPE BODY. Rimuovere prima i riferimenti dipendenti; le tabelle dati non vengono eliminate automaticamente.",
+ typeManagementDeleteBody: "Elimina solo TYPE BODY e conserva la specifica. Gli oggetti che ne chiamano i metodi possono diventare non validi.",
+ typeManagementKeepDraft: "Conserva bozza",
+ typeManagementConfirm: "Conferma esecuzione",
+ typeManagementStop: "Interrompi i passi rimanenti",
+ typeManagementResume: "Rivedi / riprendi modifiche",
+ typeManagementUseSave: "Per il sorgente TYPE usare Anteprima e salva; non eseguirlo direttamente.",
+ typeManagementPreviewSave: "Anteprima e salva",
+ typeManagementExistingDraft: "Questo oggetto ha una modifica incompleta. Si riprende il piano originale.",
+ typeManagementCloseWarning: "Chiudendo queste schede si perdono i registri locali di ripristino TYPE. Il DDL applicato e le tabelle di riferimento non vengono annullati o eliminati.",
+ typeManagementDiscardClose: "Elimina registro e chiudi",
+ typeManagementDeleted: "Oggetto eliminato. La definizione originale resta come riferimento.",
+ typeManagementRefreshFailed: "Modifiche applicate, ma aggiornamento fallito: {message}. Rileggere lo stato senza ripetere l’esecuzione.",
+ typeManagementRunningClose: "Un’istruzione TYPE è ancora in corso. Interrompere i passi rimanenti e attendere la verifica prima di chiudere.",
+ typeManagementMaintenance: "Le scritture applicative sugli oggetti interessati sono sospese e sono pronto a verificare ogni passo.",
+ typeDataTitle: "Mappatura dei dati persistenti",
+ typeDataInstructions: "Preparare e confermare tabelle scalari permanenti OLD/EXPECTED e impostarle in sola lettura nativa. Registrare tutti i valori originali prima di conversioni o rimozioni di riferimenti nell’editor SQL. Verificare i dati e poi riconvalidare il piano TYPE.",
+ typeDataSource: "Tabella / campo originale",
+ typeDataTarget: "Tabella destinazione",
+ typeDataOwner: "Proprietario esatto",
+ typeDataReadProjection: "Leggi proiezione completa",
+ typeDataTargetPath: "Percorso destinazione (JSON)",
+ typeDataUnchanged: "Mantieni valore originale",
+ typeDataPrepareHint: "OLD deve conservare tutti i valori protetti; EXPECTED descrive tutti i valori finali. I campi invariati vengono confrontati integralmente. Non sono ammesse aggiunta, rimozione o aggregazione di righe.",
+ typeDataPrepareSql: "Apri proiezione originale in SQL",
+ typeDataRegister: "Registra e salva riferimenti",
+ typeDataVerified: "Dati finali completi verificati. Riconvalidare per continuare i passaggi TYPE.",
+ typeDataWaiting: "In attesa di conversione, verifica completa e rimozione dei riferimenti TYPE.",
+ typeDataIntegrity: "Identità e integrità dei riferimenti",
+ typeDataBoundedInsert: "INSERT scalare limitato",
+ typeDataInsertHint: "È ammesso un solo INSERT SELECT con colonne esplicite da EXPECTED registrato alla tabella scalare vuota registrata. Funzioni, filtri, join e scritture implicite sono rifiutati. Preparare le conversioni complesse nell’editor SQL e tornare alla verifica.",
+ typeDataPreviewInsert: "Anteprima e convalida INSERT",
+ typeDataRunInsert: "Conferma inserimento scalare",
+ typeDataVerify: "Verifica riferimenti e destinazione",
+ typeDataKeepBaselines: "OLD/EXPECTED e i record di ripristino vengono conservati. Annullamento, errore, chiusura e completamento non eliminano mai automaticamente i riferimenti.",
+ typeDataPathError: "Il percorso finale deve essere un array JSON non vuoto di stringhe.",
+ typeManagementCurrentSource: "Sorgente attuale nel database",
+ typeManagementNativeEvolution: "L’evoluzione nativa di Oracle conserva i dati sul posto, senza preparare OLD/EXPECTED. Ogni passo verifica struttura del tipo, dipendenze e stato delle tabelle.",
+ typeManagementPreviousAttempts: "Tentativi di esecuzione precedenti",
+ typeManagementDraftLabel: "Definizione da eseguire",
+ typeManagementValidationPending: "Correggi la definizione o le dipendenze, quindi ripeti la convalida. Conferma l'esecuzione dopo una convalida riuscita.",
+ typeManagementState: {
+ "not-sent": "Non inviato",
+ sent: "Inviato",
+ confirmed: "Verificato",
+ failed: "Non riuscito",
+ unknown: "Risultato sconosciuto",
+ },
sourceSaveFailed: "Impossibile salvare il sorgente: {message}",
routineWritePending: "Non è ancora stato confermato che la richiesta originale sia terminata (operazione {operationId}). La bozza è conservata; salvando di nuovo si controlla solo la richiesta originale, senza reinviarla.",
routineWriteUnverified: "Il salvataggio non è ancora stato verificato come riuscito (operazione {operationId}). La bozza è conservata; procedi in base al risultato qui sotto.",
diff --git a/apps/desktop/src/i18n/locales/ja.ts b/apps/desktop/src/i18n/locales/ja.ts
index 558e8df8c3..d8e993dc11 100644
--- a/apps/desktop/src/i18n/locales/ja.ts
+++ b/apps/desktop/src/i18n/locales/ja.ts
@@ -363,6 +363,43 @@ export default withEnglishFallback({
incomplete: "生成された DDL は不完全なためコピーされませんでした。型の詳細で警告を確認してください。",
},
},
+ oracleType: {
+ kinds: { object: "オブジェクト型", collection: "コレクション型", other: "その他の型" },
+ source: "ソース",
+ bodySource: "型本体のソース",
+ viewBody: "型本体を表示",
+ methods: "メソッド",
+ methodMetadata: "メソッド情報",
+ parameters: "パラメーター",
+ results: "戻り値",
+ parameter: "パラメーター",
+ result: "戻り値",
+ emptyMethods: "表示可能な辞書結果にメソッドはありません。",
+ emptyAttributes: "表示可能な辞書結果に属性はありません。",
+ owner: "所有者",
+ status: "状態",
+ typeCode: "型コード",
+ isFinal: "継承不可",
+ instantiable: "インスタンス化可能",
+ supertype: "上位型",
+ attributeCount: "属性数",
+ methodCount: "メソッド数",
+ bodyStatus: "型本体の状態",
+ propertiesRead: "型プロパティ",
+ bodyRead: "型本体の対応情報",
+ boolean: { yes: "はい", no: "いいえ" },
+ bodyVisibility: "型本体の可視性",
+ bodyVisible: "現在のディクショナリ範囲で型本体を確認できます",
+ bodyNotVisible: "現在のディクショナリ範囲では型本体を確認できません",
+ unknown: "不明",
+ body: "型本体",
+ collection: "コレクション",
+ upperBound: "上限",
+ length: "長さ",
+ precision: "精度",
+ scale: "スケール",
+ read: { available: "読み込み済み", incomplete: "不完全", unavailable: "利用不可または非表示", unsupported: "未対応" },
+ },
docs,
dataDictionary,
pluginPlatform: {
@@ -5189,6 +5226,57 @@ export default withEnglishFallback({
saveSource: "保存",
cancelEdit: "キャンセル",
sourceSaved: "ソースを保存しました",
+ typeManagementTitle: "型の変更",
+ typeManagementNonAtomic: "DDL は手順ごとにコミットされます。プレビューを閉じても、下書きと実行記録はソースタブに残ります。",
+ typeManagementScope: "自動移行の対象は、このアカウントから見える依存関係のみです。他の所有者の非表示の呼び出し元は無効になる可能性があります。",
+ typeManagementDeleteSpec: "仕様を削除すると TYPE BODY も削除されます。先に依存参照を解除してください。データテーブルは自動削除されません。",
+ typeManagementDeleteBody: "TYPE BODY のみを削除し、仕様を保持します。メソッドを呼び出すオブジェクトが無効になる場合があります。",
+ typeManagementKeepDraft: "下書きを保持",
+ typeManagementConfirm: "実行を確認",
+ typeManagementStop: "残りの手順を停止",
+ typeManagementResume: "変更を確認 / 再開",
+ typeManagementUseSave: "TYPE ソースは「プレビューして保存」を使用し、直接実行しないでください。",
+ typeManagementPreviewSave: "プレビューして保存",
+ typeManagementExistingDraft: "このオブジェクトには未完了の変更があります。元の計画を再開します。",
+ typeManagementCloseWarning: "タブを閉じると、型変更のローカル復旧記録が失われます。適用済み DDL やデータベース内の基準データは取り消し・削除されません。",
+ typeManagementDiscardClose: "復旧記録を破棄して閉じる",
+ typeManagementDeleted: "オブジェクトを削除しました。元の定義は参照用に保持されます。",
+ typeManagementRefreshFailed: "変更は適用済みですが、更新に失敗しました:{message}。状態を再取得し、再実行しないでください。",
+ typeManagementRunningClose: "TYPE 文が実行中です。残りの手順を停止し、結果の確認を待ってから閉じてください。",
+ typeManagementMaintenance: "対象オブジェクトへの業務書き込みを停止し、各手順の結果を確認する準備ができています。",
+ typeDataTitle: "永続データのマッピング",
+ typeDataInstructions: "永続スカラーテーブル OLD/EXPECTED を準備してコミットし、DB ネイティブの読み取り専用に設定します。元の全値を登録してから、SQL エディターで変換と型参照の解除を行います。戻ってデータを検証し、最後に TYPE 計画を再検証します。",
+ typeDataSource: "元テーブル / フィールド",
+ typeDataTarget: "変換先テーブル",
+ typeDataOwner: "正確な所有者",
+ typeDataReadProjection: "完全な投影を読み取る",
+ typeDataTargetPath: "変換先パス(JSON)",
+ typeDataUnchanged: "元の値を保持",
+ typeDataPrepareHint: "OLD は保護対象の元の全値、EXPECTED は変換先の全値を保持する必要があります。変更しないフィールドは全件比較します。行の追加・削除・集約は対象外です。",
+ typeDataPrepareSql: "元の投影を SQL で開く",
+ typeDataRegister: "基準を登録して保存",
+ typeDataVerified: "変換先の全データを確認済みです。再検証して TYPE 手順を続行してください。",
+ typeDataWaiting: "変換、変換先の全件検証、型参照の解除を待っています。",
+ typeDataIntegrity: "基準の識別情報と完全性",
+ typeDataBoundedInsert: "制限付きスカラー INSERT",
+ typeDataInsertHint: "登録済み EXPECTED から登録済みの空のスカラーテーブルへの、明示列付き INSERT SELECT 1 文のみ対応します。関数、絞り込み、結合、暗黙の書き込みは拒否します。複雑な変換は SQL エディターで準備してから再検証してください。",
+ typeDataPreviewInsert: "INSERT をプレビュー・検証",
+ typeDataRunInsert: "スカラー書き込みを確認",
+ typeDataVerify: "元の基準と変換先を検証",
+ typeDataKeepBaselines: "OLD/EXPECTED と復旧記録は保持されます。キャンセル、失敗、終了、成功時にも基準は自動削除しません。",
+ typeDataPathError: "変換先パスは空でない文字列の JSON 配列にしてください。",
+ typeManagementCurrentSource: "データベースの現在のソース",
+ typeManagementNativeEvolution: "Oracle のネイティブ型進化でデータをその場に保持します。OLD/EXPECTED の準備は不要です。各手順で型構造、依存関係、表の状態を確認します。",
+ typeManagementPreviousAttempts: "以前の実行試行",
+ typeManagementDraftLabel: "実行する定義",
+ typeManagementValidationPending: "定義または依存関係を修正してから再検証してください。検証に成功したら実行を確認してください。",
+ typeManagementState: {
+ "not-sent": "未送信",
+ sent: "送信済み",
+ confirmed: "確認済み",
+ failed: "失敗",
+ unknown: "結果不明",
+ },
sourceSaveFailed: "ソースの保存に失敗しました: {message}",
routineWritePending: "元のリクエストの完了はまだ確認されていません(操作 {operationId})。下書きは保持されています。再度保存すると元のリクエストを確認するだけで、再送信はしません。",
routineWriteUnverified: "保存の成功はまだ確認できていません(操作 {operationId})。下書きは保持されています。以下の結果に応じて対応してください。",
diff --git a/apps/desktop/src/i18n/locales/ko.ts b/apps/desktop/src/i18n/locales/ko.ts
index 92c22efb57..34b2d7c732 100644
--- a/apps/desktop/src/i18n/locales/ko.ts
+++ b/apps/desktop/src/i18n/locales/ko.ts
@@ -361,6 +361,43 @@ export default withEnglishFallback({
incomplete: "생성된 DDL이 불완전하여 복사되지 않았습니다. 형식 세부 정보에서 경고를 확인하세요.",
},
},
+ oracleType: {
+ kinds: { object: "객체 유형", collection: "컬렉션 유형", other: "기타 유형" },
+ source: "소스",
+ bodySource: "타입 본문 소스",
+ viewBody: "타입 본문 보기",
+ methods: "메서드",
+ methodMetadata: "메서드 메타데이터",
+ parameters: "매개변수",
+ results: "결과",
+ parameter: "매개변수",
+ result: "결과",
+ emptyMethods: "표시 가능한 사전 결과에 메서드가 없습니다.",
+ emptyAttributes: "표시 가능한 사전 결과에 속성이 없습니다.",
+ owner: "소유자",
+ status: "상태",
+ typeCode: "타입 코드",
+ isFinal: "최종",
+ instantiable: "인스턴스화 가능",
+ supertype: "상위 타입",
+ attributeCount: "속성 수",
+ methodCount: "메서드 수",
+ bodyStatus: "본문 상태",
+ propertiesRead: "타입 속성",
+ bodyRead: "타입 본문 연결",
+ boolean: { yes: "예", no: "아니요" },
+ bodyVisibility: "타입 본문 표시 여부",
+ bodyVisible: "현재 사전 범위에서 타입 본문을 볼 수 있습니다",
+ bodyNotVisible: "현재 사전 범위에서 타입 본문을 볼 수 없습니다",
+ unknown: "알 수 없음",
+ body: "타입 본문",
+ collection: "컬렉션",
+ upperBound: "상한",
+ length: "길이",
+ precision: "정밀도",
+ scale: "소수 자릿수",
+ read: { available: "로드됨", incomplete: "불완전", unavailable: "사용할 수 없거나 표시되지 않음", unsupported: "지원되지 않음" },
+ },
docs,
dataDictionary,
pluginPlatform: {
@@ -5422,6 +5459,57 @@ export default withEnglishFallback({
saveSource: "저장",
cancelEdit: "취소",
sourceSaved: "소스를 저장했습니다",
+ typeManagementTitle: "타입 변경",
+ typeManagementNonAtomic: "DDL은 단계별로 커밋됩니다. 미리보기를 닫아도 소스 탭에 초안과 실행 기록이 남습니다.",
+ typeManagementScope: "자동 마이그레이션은 이 계정에 보이는 종속성만 처리합니다. 다른 소유자의 보이지 않는 호출자는 무효화될 수 있습니다.",
+ typeManagementDeleteSpec: "명세를 삭제하면 TYPE BODY도 삭제됩니다. 먼저 종속 참조를 제거해야 하며 데이터 테이블은 자동 삭제되지 않습니다.",
+ typeManagementDeleteBody: "TYPE BODY만 삭제하고 명세는 유지합니다. 메서드를 호출하는 객체가 무효화될 수 있습니다.",
+ typeManagementKeepDraft: "초안 유지",
+ typeManagementConfirm: "실행 확인",
+ typeManagementStop: "남은 단계 중지",
+ typeManagementResume: "변경 검토 / 계속",
+ typeManagementUseSave: "TYPE 소스는 직접 실행하지 말고 ‘미리보기 및 저장’을 사용하세요.",
+ typeManagementPreviewSave: "미리보기 및 저장",
+ typeManagementExistingDraft: "이 객체에 미완료 변경이 있어 원래 계획을 계속합니다.",
+ typeManagementCloseWarning: "탭을 닫으면 로컬 타입 변경 복구 기록이 삭제됩니다. 적용된 DDL이나 데이터베이스 기준 데이터는 취소되거나 삭제되지 않습니다.",
+ typeManagementDiscardClose: "복구 기록 삭제 후 닫기",
+ typeManagementDeleted: "객체가 삭제되었습니다. 원래 정의는 참고용으로 유지됩니다.",
+ typeManagementRefreshFailed: "변경은 적용됐지만 새로 고침에 실패했습니다: {message}. 상태를 다시 읽고 재실행하지 마세요.",
+ typeManagementRunningClose: "TYPE 문이 아직 실행 중입니다. 남은 단계를 중지하고 결과 확인 후 닫으세요.",
+ typeManagementMaintenance: "영향받는 객체에 대한 업무 쓰기를 중지했으며 각 단계의 결과를 확인할 준비가 되었습니다.",
+ typeDataTitle: "영구 데이터 매핑",
+ typeDataInstructions: "영구 스칼라 OLD/EXPECTED 테이블을 준비하고 커밋한 뒤 DB 기본 읽기 전용으로 설정하세요. 원본 전체 값을 등록한 후 SQL 편집기에서 변환과 형식 참조 해제를 수행하세요. 데이터를 검증하고 TYPE 계획을 다시 검증하세요.",
+ typeDataSource: "원본 테이블 / 필드",
+ typeDataTarget: "대상 테이블",
+ typeDataOwner: "정확한 소유자",
+ typeDataReadProjection: "전체 투영 읽기",
+ typeDataTargetPath: "대상 필드 경로(JSON)",
+ typeDataUnchanged: "원본 값 유지",
+ typeDataPrepareHint: "OLD는 보호되는 원본 전체 값, EXPECTED는 대상 전체 값을 보관해야 합니다. 변경하지 않은 필드는 전체 비교합니다. 행 추가·삭제·집계는 지원하지 않습니다.",
+ typeDataPrepareSql: "SQL 편집기에서 원본 투영 열기",
+ typeDataRegister: "기준 등록 및 저장",
+ typeDataVerified: "대상 전체 데이터가 검증되었습니다. 다시 검증하여 TYPE 단계를 계속하세요.",
+ typeDataWaiting: "변환, 대상 전체 검증 및 TYPE 참조 해제를 기다립니다.",
+ typeDataIntegrity: "기준 식별 정보 및 무결성",
+ typeDataBoundedInsert: "제한된 스칼라 INSERT",
+ typeDataInsertHint: "등록된 EXPECTED에서 등록된 빈 스칼라 테이블로 명시적 열을 지정한 단일 INSERT SELECT만 허용합니다. 함수, 필터, 조인 및 암시적 쓰기는 거부합니다. 복잡한 변환은 SQL 편집기에서 준비한 뒤 검증하세요.",
+ typeDataPreviewInsert: "INSERT 미리 보기 및 검증",
+ typeDataRunInsert: "스칼라 삽입 확인",
+ typeDataVerify: "원본 기준 및 대상 검증",
+ typeDataKeepBaselines: "OLD/EXPECTED 및 복구 기록은 유지됩니다. 취소, 실패, 닫기, 성공 시에도 기준을 자동 삭제하지 않습니다.",
+ typeDataPathError: "대상 경로는 비어 있지 않은 문자열 JSON 배열이어야 합니다.",
+ typeManagementCurrentSource: "현재 데이터베이스 소스",
+ typeManagementNativeEvolution: "Oracle 기본 타입 진화로 데이터를 제자리에 보존하며 OLD/EXPECTED 준비가 필요하지 않습니다. 각 단계에서 타입 구조, 종속성 및 테이블 상태를 확인합니다.",
+ typeManagementPreviousAttempts: "이전 실행 시도",
+ typeManagementDraftLabel: "실행할 정의",
+ typeManagementValidationPending: "정의 또는 종속성을 수정한 후 다시 검증하세요. 검증이 성공하면 실행을 확인하세요.",
+ typeManagementState: {
+ "not-sent": "미전송",
+ sent: "전송됨",
+ confirmed: "확인됨",
+ failed: "실패",
+ unknown: "결과 알 수 없음",
+ },
sourceSaveFailed: "소스 저장에 실패했습니다: {message}",
routineWritePending: "원래 요청이 완료되었는지 아직 확인되지 않았습니다(작업 {operationId}). 초안은 보존됩니다. 다시 저장하면 원래 요청만 확인하며 재전송하지 않습니다.",
routineWriteUnverified: "저장이 성공했는지 아직 확인되지 않았습니다(작업 {operationId}). 초안은 보존됩니다. 아래 결과에 따라 처리하세요.",
diff --git a/apps/desktop/src/i18n/locales/pt-BR.ts b/apps/desktop/src/i18n/locales/pt-BR.ts
index 9f1d8dcb01..6b7e3bae3e 100644
--- a/apps/desktop/src/i18n/locales/pt-BR.ts
+++ b/apps/desktop/src/i18n/locales/pt-BR.ts
@@ -363,6 +363,43 @@ export default withEnglishFallback({
incomplete: "O DDL gerado está incompleto e não foi copiado. Abra os detalhes do tipo para revisar os avisos.",
},
},
+ oracleType: {
+ kinds: { object: "Tipo de objeto", collection: "Tipo de coleção", other: "Outro tipo" },
+ source: "Código-fonte",
+ bodySource: "Código do corpo do tipo",
+ viewBody: "Ver corpo do tipo",
+ methods: "Métodos",
+ methodMetadata: "Metadados de métodos",
+ parameters: "Parâmetros",
+ results: "Resultados",
+ parameter: "Parâmetro",
+ result: "Resultado",
+ emptyMethods: "Nenhum método no resultado visível do dicionário.",
+ emptyAttributes: "Nenhum atributo no resultado visível do dicionário.",
+ owner: "Proprietário",
+ status: "Status",
+ typeCode: "Código do tipo",
+ isFinal: "Final",
+ instantiable: "Instanciável",
+ supertype: "Supertipo",
+ attributeCount: "Quantidade de atributos",
+ methodCount: "Quantidade de métodos",
+ bodyStatus: "Status do corpo",
+ propertiesRead: "Propriedades do tipo",
+ bodyRead: "Leitura do corpo do tipo",
+ boolean: { yes: "Sim", no: "Não" },
+ bodyVisibility: "Visibilidade do corpo do tipo",
+ bodyVisible: "O corpo do tipo está visível no escopo atual do dicionário",
+ bodyNotVisible: "Nenhum corpo do tipo está visível no escopo atual do dicionário",
+ unknown: "Desconhecido",
+ body: "Corpo do tipo",
+ collection: "Coleção",
+ upperBound: "Limite superior",
+ length: "Comprimento",
+ precision: "Precisão",
+ scale: "Escala",
+ read: { available: "Carregado", incomplete: "Incompleto", unavailable: "Indisponível ou não visível", unsupported: "Não compatível" },
+ },
docs,
dataDictionary,
pluginPlatform: {
@@ -5127,6 +5164,57 @@ export default withEnglishFallback({
saveSource: "Salvar",
cancelEdit: "Cancelar",
sourceSaved: "Código-fonte salvo",
+ typeManagementTitle: "Alterações de TYPE",
+ typeManagementNonAtomic: "O DDL é confirmado por etapa. Fechar a prévia mantém os rascunhos e registros na aba do código.",
+ typeManagementScope: "A migração automática cobre apenas dependências visíveis a esta conta. Chamadores ocultos de outros proprietários podem se tornar inválidos.",
+ typeManagementDeleteSpec: "Excluir a especificação também exclui TYPE BODY. Remova antes as referências dependentes; as tabelas de dados não são excluídas automaticamente.",
+ typeManagementDeleteBody: "Excluir apenas TYPE BODY e manter a especificação. Objetos que chamam seus métodos podem ficar inválidos.",
+ typeManagementKeepDraft: "Manter rascunho",
+ typeManagementConfirm: "Confirmar execução",
+ typeManagementStop: "Parar etapas restantes",
+ typeManagementResume: "Revisar / retomar alterações",
+ typeManagementUseSave: "Use Prévia e salvar para o código TYPE; não o execute diretamente.",
+ typeManagementPreviewSave: "Prévia e salvar",
+ typeManagementExistingDraft: "Este objeto tem uma alteração incompleta. Retomando o plano original.",
+ typeManagementCloseWarning: "Fechar estas abas descarta os registros locais de recuperação de TYPE. O DDL aplicado e as bases de comparação no banco não são desfeitos ou excluídos.",
+ typeManagementDiscardClose: "Descartar registro e fechar",
+ typeManagementDeleted: "Objeto excluído. A definição original foi mantida para referência.",
+ typeManagementRefreshFailed: "Alterações aplicadas, mas a atualização falhou: {message}. Consulte o estado; não execute novamente.",
+ typeManagementRunningClose: "Uma instrução TYPE ainda está em andamento. Pare as etapas restantes e aguarde a verificação antes de fechar.",
+ typeManagementMaintenance: "As gravações de negócio nos objetos afetados estão pausadas e estou pronto para verificar cada etapa.",
+ typeDataTitle: "Mapeamento de dados persistentes",
+ typeDataInstructions: "Prepare e confirme tabelas escalares permanentes OLD/EXPECTED e defina-as como somente leitura nativa. Registre todos os valores originais antes de converter ou remover referências no editor SQL. Verifique os dados e depois revalide o plano TYPE.",
+ typeDataSource: "Tabela / campo original",
+ typeDataTarget: "Tabela de destino",
+ typeDataOwner: "Proprietário exato",
+ typeDataReadProjection: "Ler projeção completa",
+ typeDataTargetPath: "Caminho de destino (JSON)",
+ typeDataUnchanged: "Manter valor original",
+ typeDataPrepareHint: "OLD deve preservar todos os valores protegidos; EXPECTED descreve todos os valores finais. Campos inalterados são comparados integralmente. Não há inclusão, remoção ou agregação de linhas.",
+ typeDataPrepareSql: "Abrir projeção original no SQL",
+ typeDataRegister: "Registrar e salvar bases",
+ typeDataVerified: "Dados completos do destino verificados. Revalide para continuar as etapas TYPE.",
+ typeDataWaiting: "Aguardando conversão, verificação completa e remoção de referências TYPE.",
+ typeDataIntegrity: "Identidade e integridade das bases",
+ typeDataBoundedInsert: "INSERT escalar limitado",
+ typeDataInsertHint: "Aceita apenas um INSERT SELECT com colunas explícitas do EXPECTED registrado para a tabela escalar vazia registrada. Funções, filtros, junções e gravações implícitas são rejeitados. Prepare conversões complexas no editor SQL e volte para verificar.",
+ typeDataPreviewInsert: "Visualizar e validar INSERT",
+ typeDataRunInsert: "Confirmar inserção escalar",
+ typeDataVerify: "Verificar bases e destino",
+ typeDataKeepBaselines: "OLD/EXPECTED e os registros de recuperação são preservados. Cancelamento, falha, fechamento e sucesso nunca excluem bases automaticamente.",
+ typeDataPathError: "O caminho de destino deve ser um array JSON não vazio de strings.",
+ typeManagementCurrentSource: "Código atual no banco de dados",
+ typeManagementNativeEvolution: "A evolução nativa do Oracle preserva os dados no local, sem preparar OLD/EXPECTED. Cada etapa verifica a estrutura do tipo, as dependências e o estado das tabelas.",
+ typeManagementPreviousAttempts: "Tentativas de execução anteriores",
+ typeManagementDraftLabel: "Definição a executar",
+ typeManagementValidationPending: "Corrija a definição ou as dependências e valide novamente. Confirme a execução após a validação ser concluída com sucesso.",
+ typeManagementState: {
+ "not-sent": "Não enviado",
+ sent: "Enviado",
+ confirmed: "Verificado",
+ failed: "Falhou",
+ unknown: "Resultado desconhecido",
+ },
sourceSaveFailed: "Falha ao salvar código-fonte: {message}",
routineWritePending: "Ainda não foi confirmado que a solicitação original terminou (operação {operationId}). O rascunho foi preservado; salvar novamente apenas verifica a solicitação original, sem reenviá-la.",
routineWriteUnverified: "Ainda não foi confirmado que o salvamento foi bem-sucedido (operação {operationId}). O rascunho foi preservado; aja conforme o resultado abaixo.",
diff --git a/apps/desktop/src/i18n/locales/ru.ts b/apps/desktop/src/i18n/locales/ru.ts
index 8fe110f755..44c8dc78ea 100644
--- a/apps/desktop/src/i18n/locales/ru.ts
+++ b/apps/desktop/src/i18n/locales/ru.ts
@@ -212,6 +212,43 @@ export default withEnglishFallback({
resultChanged: "Результат или подключение изменились. Обновите и повторите попытку.",
updateFailed: "Не удалось обновить свойство.",
},
+ oracleType: {
+ kinds: { object: "Объектный тип", collection: "Тип коллекции", other: "Другой тип" },
+ source: "Исходный код",
+ bodySource: "Исходный код тела типа",
+ viewBody: "Открыть тело типа",
+ methods: "Методы",
+ methodMetadata: "Метаданные методов",
+ parameters: "Параметры",
+ results: "Результаты",
+ parameter: "Параметр",
+ result: "Результат",
+ emptyMethods: "В видимой выборке словаря нет методов.",
+ emptyAttributes: "В видимой выборке словаря нет атрибутов.",
+ owner: "Владелец",
+ status: "Состояние",
+ typeCode: "Код типа",
+ isFinal: "Финальный",
+ instantiable: "Можно создать экземпляр",
+ supertype: "Супертип",
+ attributeCount: "Число атрибутов",
+ methodCount: "Число методов",
+ bodyStatus: "Состояние тела",
+ propertiesRead: "Свойства типа",
+ bodyRead: "Сведения о теле типа",
+ boolean: { yes: "Да", no: "Нет" },
+ bodyVisibility: "Видимость тела типа",
+ bodyVisible: "Тело типа видно в текущей области словаря",
+ bodyNotVisible: "В текущей области словаря тело типа не видно",
+ unknown: "Неизвестно",
+ body: "Тело типа",
+ collection: "Коллекция",
+ upperBound: "Верхняя граница",
+ length: "Длина",
+ precision: "Точность",
+ scale: "Масштаб",
+ read: { available: "Загружено", incomplete: "Неполные данные", unavailable: "Недоступно или не видно", unsupported: "Не поддерживается" },
+ },
docs,
dataDictionary,
cellTransform: {
@@ -5897,6 +5934,57 @@ export default withEnglishFallback({
saveSource: "Сохранить",
cancelEdit: "Отмена",
sourceSaved: "Исходный код сохранён",
+ typeManagementTitle: "Изменения TYPE",
+ typeManagementNonAtomic: "DDL фиксируется поэтапно. При закрытии просмотра черновики и записи выполнения сохраняются во вкладке исходного кода.",
+ typeManagementScope: "Автоматическая миграция охватывает только зависимости, видимые этой учётной записи. Невидимые вызывающие объекты других владельцев могут стать недействительными.",
+ typeManagementDeleteSpec: "Удаление спецификации также удаляет TYPE BODY. Сначала устраните зависимые ссылки; таблицы данных автоматически не удаляются.",
+ typeManagementDeleteBody: "Удалить только TYPE BODY, сохранив спецификацию. Объекты, вызывающие его методы, могут стать недействительными.",
+ typeManagementKeepDraft: "Сохранить черновик",
+ typeManagementConfirm: "Подтвердить выполнение",
+ typeManagementStop: "Остановить оставшиеся шаги",
+ typeManagementResume: "Просмотреть / продолжить",
+ typeManagementUseSave: "Для исходного кода TYPE используйте «Просмотр и сохранение», а не прямое выполнение.",
+ typeManagementPreviewSave: "Просмотр и сохранение",
+ typeManagementExistingDraft: "У объекта есть незавершённое изменение. Продолжается исходный план.",
+ typeManagementCloseWarning: "Закрытие вкладок удалит локальные записи восстановления TYPE. Применённый DDL и эталонные данные в базе не отменяются и не удаляются.",
+ typeManagementDiscardClose: "Удалить запись и закрыть",
+ typeManagementDeleted: "Объект удалён. Исходное определение сохранено для справки.",
+ typeManagementRefreshFailed: "Изменения применены, но обновление не удалось: {message}. Прочитайте состояние, не выполняйте повторно.",
+ typeManagementRunningClose: "Оператор TYPE ещё выполняется. Остановите оставшиеся шаги и дождитесь проверки перед закрытием.",
+ typeManagementMaintenance: "Запись прикладных данных в затронутые объекты приостановлена; я готов проверить результат каждого шага.",
+ typeDataTitle: "Сопоставление постоянных данных",
+ typeDataInstructions: "Подготовьте и зафиксируйте постоянные скалярные таблицы OLD/EXPECTED и включите штатный режим только чтения. Зарегистрируйте все исходные значения до преобразования и удаления ссылок в SQL-редакторе. Проверьте данные, затем повторно проверьте план TYPE.",
+ typeDataSource: "Исходная таблица / поле",
+ typeDataTarget: "Целевая таблица",
+ typeDataOwner: "Точное имя владельца",
+ typeDataReadProjection: "Прочитать всю проекцию",
+ typeDataTargetPath: "Путь целевого поля (JSON)",
+ typeDataUnchanged: "Сохранить исходное значение",
+ typeDataPrepareHint: "OLD должна содержать все защищаемые исходные значения, EXPECTED — все целевые значения. Неизменяемые поля сравниваются полностью. Добавление, удаление и агрегация строк не поддерживаются.",
+ typeDataPrepareSql: "Открыть исходную проекцию в SQL",
+ typeDataRegister: "Зарегистрировать и сохранить базы",
+ typeDataVerified: "Все целевые данные проверены. Повторно проверьте план для продолжения шагов TYPE.",
+ typeDataWaiting: "Ожидаются преобразование, полная проверка данных и удаление ссылок TYPE.",
+ typeDataIntegrity: "Идентичность и целостность баз",
+ typeDataBoundedInsert: "Ограниченный скалярный INSERT",
+ typeDataInsertHint: "Допускается один INSERT SELECT с явными столбцами из зарегистрированной EXPECTED в зарегистрированную пустую скалярную таблицу. Функции, фильтры, соединения и неявные записи запрещены. Подготовьте сложное преобразование в SQL-редакторе и вернитесь к проверке.",
+ typeDataPreviewInsert: "Предпросмотр и проверка INSERT",
+ typeDataRunInsert: "Подтвердить скалярную вставку",
+ typeDataVerify: "Проверить исходные базы и цель",
+ typeDataKeepBaselines: "OLD/EXPECTED и записи восстановления сохраняются. Отмена, ошибка, закрытие и успех никогда не удаляют базы автоматически.",
+ typeDataPathError: "Целевой путь должен быть непустым JSON-массивом строк.",
+ typeManagementCurrentSource: "Текущий исходный код в базе",
+ typeManagementNativeEvolution: "Нативное изменение типа Oracle сохраняет данные на месте; подготовка OLD/EXPECTED не требуется. На каждом шаге проверяются структура типа, зависимости и состояние таблиц.",
+ typeManagementPreviousAttempts: "Предыдущие попытки выполнения",
+ typeManagementDraftLabel: "Определение для выполнения",
+ typeManagementValidationPending: "Исправьте определение или зависимости и повторите проверку. Подтвердите выполнение после успешной проверки.",
+ typeManagementState: {
+ "not-sent": "Не отправлено",
+ sent: "Отправлено",
+ confirmed: "Проверено",
+ failed: "Ошибка",
+ unknown: "Результат неизвестен",
+ },
sourceSaveFailed: "Не удалось сохранить исходный код: {message}",
routineWritePending: "Завершение исходного запроса ещё не подтверждено (операция {operationId}). Черновик сохранён; повторное сохранение только проверяет исходный запрос и не отправляет его повторно.",
routineWriteUnverified: "Успешное сохранение ещё не подтверждено (операция {operationId}). Черновик сохранён; действуйте согласно результату ниже.",
diff --git a/apps/desktop/src/i18n/locales/th.ts b/apps/desktop/src/i18n/locales/th.ts
index e5f599d493..b2aa6cc36a 100644
--- a/apps/desktop/src/i18n/locales/th.ts
+++ b/apps/desktop/src/i18n/locales/th.ts
@@ -6219,6 +6219,57 @@ export default withEnglishFallback({
saveSource: "บันทึก",
cancelEdit: "ยกเลิก",
sourceSaved: "บันทึก Source แล้ว",
+ typeManagementTitle: "การเปลี่ยนแปลง TYPE",
+ typeManagementNonAtomic: "DDL จะคอมมิตทีละขั้น การปิดตัวอย่างยังคงเก็บฉบับร่างและบันทึกการทำงานไว้ในแท็บซอร์ส",
+ typeManagementScope: "การย้ายอัตโนมัติครอบคลุมเฉพาะการอ้างอิงที่บัญชีนี้มองเห็น ผู้เรียกของเจ้าของอื่นที่มองไม่เห็นอาจใช้งานไม่ได้",
+ typeManagementDeleteSpec: "การลบข้อกำหนดจะลบ TYPE BODY ด้วย ต้องยกเลิกการอ้างอิงที่เกี่ยวข้องก่อน โดยจะไม่ลบตารางข้อมูลโดยอัตโนมัติ",
+ typeManagementDeleteBody: "ลบเฉพาะ TYPE BODY และคงข้อกำหนดไว้ อ็อบเจ็กต์ที่เรียกเมธอดอาจไม่ถูกต้อง",
+ typeManagementKeepDraft: "เก็บฉบับร่าง",
+ typeManagementConfirm: "ยืนยันการทำงาน",
+ typeManagementStop: "หยุดขั้นตอนที่เหลือ",
+ typeManagementResume: "ตรวจสอบ / ทำต่อ",
+ typeManagementUseSave: "สำหรับซอร์ส TYPE ให้ใช้ ‘ดูตัวอย่างและบันทึก’ แทนการรันโดยตรง",
+ typeManagementPreviewSave: "ดูตัวอย่างและบันทึก",
+ typeManagementExistingDraft: "อ็อบเจ็กต์นี้มีการเปลี่ยนแปลงที่ยังไม่เสร็จ กำลังดำเนินแผนเดิมต่อ",
+ typeManagementCloseWarning: "การปิดแท็บจะทิ้งบันทึกกู้คืน TYPE ในเครื่อง แต่ไม่ย้อนกลับ DDL ที่ทำแล้วหรือลบข้อมูลอ้างอิงในฐานข้อมูล",
+ typeManagementDiscardClose: "ทิ้งบันทึกแล้วปิด",
+ typeManagementDeleted: "ลบอ็อบเจ็กต์แล้ว โดยเก็บข้อกำหนดเดิมไว้สำหรับอ้างอิง",
+ typeManagementRefreshFailed: "ใช้การเปลี่ยนแปลงแล้ว แต่รีเฟรชล้มเหลว: {message} โปรดอ่านสถานะใหม่ อย่ารันซ้ำ",
+ typeManagementRunningClose: "คำสั่ง TYPE ยังอยู่ระหว่างทำงาน โปรดหยุดขั้นตอนที่เหลือและรออ่านผลก่อนปิด",
+ typeManagementMaintenance: "หยุดการเขียนข้อมูลทางธุรกิจลงอ็อบเจ็กต์ที่ได้รับผลกระทบแล้ว และพร้อมตรวจสอบผลของแต่ละขั้น",
+ typeDataTitle: "การจับคู่ข้อมูลถาวร",
+ typeDataInstructions: "เตรียมและคอมมิตตารางสเกลาร์ถาวร OLD/EXPECTED แล้วตั้งเป็นอ่านอย่างเดียวของฐานข้อมูล ลงทะเบียนค่าต้นฉบับทั้งหมดก่อนแปลงหรือยกเลิกการอ้างอิงในตัวแก้ไข SQL กลับมาตรวจข้อมูลแล้วตรวจแผน TYPE อีกครั้ง",
+ typeDataSource: "ตาราง / ฟิลด์ต้นฉบับ",
+ typeDataTarget: "ตารางเป้าหมาย",
+ typeDataOwner: "เจ้าของตรงตามชื่อ",
+ typeDataReadProjection: "อ่านข้อมูลฉายทั้งหมด",
+ typeDataTargetPath: "พาธฟิลด์เป้าหมาย (JSON)",
+ typeDataUnchanged: "เก็บค่าเดิม",
+ typeDataPrepareHint: "OLD ต้องเก็บค่าต้นฉบับที่ป้องกันไว้ทั้งหมด และ EXPECTED ระบุค่าเป้าหมายทั้งหมด ฟิลด์ที่ไม่เปลี่ยนจะถูกเปรียบเทียบครบถ้วน ไม่รองรับการเพิ่ม ลบ หรือรวมแถว",
+ typeDataPrepareSql: "เปิดข้อมูลฉายต้นฉบับใน SQL",
+ typeDataRegister: "ลงทะเบียนและบันทึกข้อมูลฐาน",
+ typeDataVerified: "ตรวจข้อมูลเป้าหมายครบแล้ว ตรวจแผนอีกครั้งเพื่อดำเนินขั้นตอน TYPE ต่อ",
+ typeDataWaiting: "รอการแปลง ตรวจข้อมูลเป้าหมายครบ และยกเลิกการอ้างอิง TYPE",
+ typeDataIntegrity: "ตัวตนและความสมบูรณ์ของข้อมูลฐาน",
+ typeDataBoundedInsert: "INSERT สเกลาร์แบบจำกัด",
+ typeDataInsertHint: "ยอมรับ INSERT SELECT เดียวที่ระบุคอลัมน์ชัดเจนจาก EXPECTED ที่ลงทะเบียนไปยังตารางสเกลาร์ว่างที่ลงทะเบียนเท่านั้น ไม่ยอมรับฟังก์ชัน ตัวกรอง การเชื่อมตาราง และการเขียนโดยนัย เตรียมการแปลงซับซ้อนในตัวแก้ไข SQL แล้วกลับมาตรวจสอบ",
+ typeDataPreviewInsert: "ดูตัวอย่างและตรวจ INSERT",
+ typeDataRunInsert: "ยืนยันการแทรกสเกลาร์",
+ typeDataVerify: "ตรวจข้อมูลฐานเดิมและเป้าหมาย",
+ typeDataKeepBaselines: "เก็บ OLD/EXPECTED และบันทึกกู้คืนไว้เสมอ การยกเลิก ล้มเหลว ปิด หรือสำเร็จจะไม่ลบข้อมูลฐานอัตโนมัติ",
+ typeDataPathError: "พาธเป้าหมายต้องเป็นอาร์เรย์ JSON ของสตริงที่ไม่ว่าง",
+ typeManagementCurrentSource: "ซอร์สปัจจุบันในฐานข้อมูล",
+ typeManagementNativeEvolution: "การปรับชนิดข้อมูลแบบเนทีฟของ Oracle เก็บข้อมูลไว้ที่เดิม ไม่ต้องเตรียม OLD/EXPECTED แต่ละขั้นจะตรวจสอบโครงสร้างชนิดข้อมูล ความเชื่อมโยง และสถานะตาราง",
+ typeManagementPreviousAttempts: "ความพยายามดำเนินการก่อนหน้า",
+ typeManagementDraftLabel: "นิยามที่จะดำเนินการ",
+ typeManagementValidationPending: "แก้ไขนิยามหรือการอ้างอิง แล้วตรวจสอบอีกครั้ง เมื่อตรวจสอบผ่านจึงยืนยันการดำเนินการ",
+ typeManagementState: {
+ "not-sent": "ยังไม่ส่ง",
+ sent: "ส่งแล้ว",
+ confirmed: "ตรวจสอบแล้ว",
+ failed: "ล้มเหลว",
+ unknown: "ไม่ทราบผล",
+ },
sourceSaveFailed: "บันทึก Source ไม่สำเร็จ: {message}",
routineWritePending: "ยังไม่ยืนยันว่าคำขอเดิมเสร็จสิ้นแล้ว (การดำเนินการ {operationId}) เก็บฉบับร่างไว้แล้ว การบันทึกอีกครั้งจะตรวจสอบเฉพาะคำขอเดิมและจะไม่ส่งซ้ำ",
routineWriteUnverified: "ยังไม่ได้ยืนยันว่าบันทึกสำเร็จ (การดำเนินการ {operationId}) เก็บฉบับร่างไว้แล้ว โปรดดำเนินการตามผลด้านล่าง",
@@ -13653,5 +13704,42 @@ export default withEnglishFallback({
authFailed: "ตรวจสอบ Authentication ของ DBX ไม่ได้",
retry: "ลองอีกครั้ง",
},
+ oracleType: {
+ kinds: { object: "ชนิดออบเจ็กต์", collection: "ชนิดคอลเลกชัน", other: "ชนิดอื่น" },
+ source: "ซอร์ส",
+ bodySource: "ซอร์สส่วนเนื้อหาของชนิด",
+ viewBody: "ดูเนื้อหาของชนิด",
+ methods: "เมธอด",
+ methodMetadata: "ข้อมูลเมตาของเมธอด",
+ parameters: "พารามิเตอร์",
+ results: "ผลลัพธ์",
+ parameter: "พารามิเตอร์",
+ result: "ผลลัพธ์",
+ emptyMethods: "ไม่พบเมธอดในผลลัพธ์พจนานุกรมที่มองเห็นได้",
+ emptyAttributes: "ไม่พบแอตทริบิวต์ในผลลัพธ์พจนานุกรมที่มองเห็นได้",
+ owner: "เจ้าของ",
+ status: "สถานะ",
+ typeCode: "รหัสชนิด",
+ isFinal: "ชนิดสุดท้าย",
+ instantiable: "สร้างอินสแตนซ์ได้",
+ supertype: "ชนิดแม่",
+ attributeCount: "จำนวนแอตทริบิวต์",
+ methodCount: "จำนวนเมธอด",
+ bodyStatus: "สถานะเนื้อหา",
+ propertiesRead: "คุณสมบัติชนิด",
+ bodyRead: "การจับคู่เนื้อหาชนิด",
+ boolean: { yes: "ใช่", no: "ไม่" },
+ bodyVisibility: "การมองเห็นเนื้อหาชนิด",
+ bodyVisible: "มองเห็นเนื้อหาชนิดในขอบเขตพจนานุกรมปัจจุบัน",
+ bodyNotVisible: "ไม่พบเนื้อหาชนิดที่มองเห็นได้ในขอบเขตพจนานุกรมปัจจุบัน",
+ unknown: "ไม่ทราบ",
+ body: "เนื้อหาชนิด",
+ collection: "คอลเลกชัน",
+ upperBound: "ขอบเขตบน",
+ length: "ความยาว",
+ precision: "ความละเอียด",
+ scale: "มาตราส่วน",
+ read: { available: "โหลดแล้ว", incomplete: "ไม่สมบูรณ์", unavailable: "ไม่มีหรือมองไม่เห็น", unsupported: "ไม่รองรับ" },
+ },
docs,
});
diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.ts
index 1862d566b9..067f27a414 100644
--- a/apps/desktop/src/i18n/locales/zh-CN.ts
+++ b/apps/desktop/src/i18n/locales/zh-CN.ts
@@ -451,6 +451,43 @@ export default withEnglishFallback({
incomplete: "生成的 DDL 不完整,未复制。请打开类型详情查看警告。",
},
},
+ oracleType: {
+ kinds: { object: "对象类型", collection: "集合类型", other: "其他类型" },
+ source: "源码",
+ bodySource: "类型体源码",
+ viewBody: "查看类型体",
+ methods: "方法",
+ methodMetadata: "方法信息",
+ parameters: "参数",
+ results: "结果",
+ parameter: "参数",
+ result: "结果",
+ emptyMethods: "当前可见字典结果中没有方法记录。",
+ emptyAttributes: "当前可见字典结果中没有属性记录。",
+ owner: "Owner",
+ status: "状态",
+ typeCode: "类型分类",
+ isFinal: "不可派生",
+ instantiable: "可实例化",
+ supertype: "父类型",
+ attributeCount: "属性数",
+ methodCount: "方法数",
+ bodyStatus: "类型体状态",
+ propertiesRead: "类型属性读取",
+ bodyRead: "类型体配对读取",
+ boolean: { yes: "是", no: "否" },
+ bodyVisibility: "类型体可见性",
+ bodyVisible: "当前字典可见范围内存在类型体",
+ bodyNotVisible: "当前字典可见范围内没有类型体",
+ unknown: "未知",
+ body: "类型体",
+ collection: "集合信息",
+ upperBound: "上限",
+ length: "长度",
+ precision: "精度",
+ scale: "小数位",
+ read: { available: "已读取", incomplete: "信息不完整", unavailable: "不可用或不可见", unsupported: "不支持" },
+ },
docs,
dataDictionary,
pluginPlatform: {
@@ -6225,6 +6262,57 @@ export default withEnglishFallback({
saveSource: "保存",
cancelEdit: "取消",
sourceSaved: "源码已保存",
+ typeManagementTitle: "类型变更",
+ typeManagementNonAtomic: "DDL 逐步提交。关闭预览会保留源码页签中的草稿和执行记录。",
+ typeManagementScope: "自动迁移仅覆盖当前账号可见的依赖;不可见的跨账号调用方可能失效。",
+ typeManagementDeleteSpec: "删除规范也会删除 TYPE BODY。必须先解除依赖引用,不会自动删除数据表。",
+ typeManagementDeleteBody: "仅删除 TYPE BODY,规范保留;调用其方法的对象可能失效。",
+ typeManagementKeepDraft: "保留草稿",
+ typeManagementConfirm: "确认执行",
+ typeManagementStop: "停止后续步骤",
+ typeManagementResume: "查看变更 / 续作",
+ typeManagementUseSave: "TYPE 源码请使用“预览并保存”,不要直接执行。",
+ typeManagementPreviewSave: "预览并保存",
+ typeManagementExistingDraft: "此对象已有未完成的变更,正在继续原计划。",
+ typeManagementCloseWarning: "关闭将丢失这些页签中的类型变更续作记录。已执行的 DDL 和数据库中的数据基准不会撤销或删除。",
+ typeManagementDiscardClose: "丢弃续作记录并关闭",
+ typeManagementDeleted: "对象已删除;原定义保留供参考。",
+ typeManagementRefreshFailed: "变更已写入,但刷新失败:{message}。请重新读取,不要重复执行。",
+ typeManagementRunningClose: "类型变更仍有语句在途。请先在预览中停止后续步骤,等待读回结果后再关闭。",
+ typeManagementMaintenance: "已暂停受影响对象的业务写入,并准备好核对逐步执行的结果。",
+ typeDataTitle: "持久化数据映射",
+ typeDataInstructions: "先准备并提交永久 OLD/EXPECTED 标量表并置为原生只读。登记完整旧值后,再到 SQL 编辑器完成转换和解除类型引用;返回核验数据,最后重新校验类型计划。",
+ typeDataSource: "原表 / 字段",
+ typeDataTarget: "目标表",
+ typeDataOwner: "Owner(精确)",
+ typeDataReadProjection: "读取完整投影",
+ typeDataTargetPath: "目标字段路径(JSON)",
+ typeDataUnchanged: "保持原值",
+ typeDataPrepareHint: "OLD 必须保留原表全部受保护值,EXPECTED 描述全部目标值。保持原值的字段会完整比较;不支持增删行或聚合。",
+ typeDataPrepareSql: "在 SQL 编辑器查看原投影",
+ typeDataRegister: "登记并保存原基准",
+ typeDataVerified: "目标完整数据已核实;重新校验后可继续类型步骤。",
+ typeDataWaiting: "等待转换、目标数据核验和解除类型引用。",
+ typeDataIntegrity: "基准身份与完整性",
+ typeDataBoundedInsert: "受限标量 INSERT",
+ typeDataInsertHint: "仅支持从登记 EXPECTED 向登记空标量表进行一条显式列 INSERT SELECT。函数、过滤、联接及隐藏写入入口均不接受;复杂转换请在 SQL 编辑器完成后返回核验。",
+ typeDataPreviewInsert: "预览并校验 INSERT",
+ typeDataRunInsert: "确认写入标量目标",
+ typeDataVerify: "核验原基准与目标数据",
+ typeDataKeepBaselines: "OLD/EXPECTED 和续作记录会保留。取消、失败、关闭及成功均不自动删除基准。",
+ typeDataPathError: "目标字段路径必须是非空 JSON 字符串数组。",
+ typeManagementCurrentSource: "数据库当前源码",
+ typeManagementNativeEvolution: "使用 Oracle 原生演进,原位保留数据,无需准备 OLD/EXPECTED。每步核对类型结构、依赖和表状态。",
+ typeManagementPreviousAttempts: "之前的执行尝试",
+ typeManagementDraftLabel: "待执行定义",
+ typeManagementValidationPending: "修正定义或依赖后,点击“重新校验”;通过后再确认执行。",
+ typeManagementState: {
+ "not-sent": "未发送",
+ sent: "已发送",
+ confirmed: "已核实",
+ failed: "失败",
+ unknown: "结果未知",
+ },
sourceSaveFailed: "保存源码失败:{message}",
routineWritePending: "原请求尚未确认结束(操作 {operationId})。草稿已保留;再次保存只核对原请求,不重发。",
routineWriteUnverified: "尚未验证保存成功(操作 {operationId})。草稿已保留,请根据下方结果处理。",
diff --git a/apps/desktop/src/i18n/locales/zh-TW.ts b/apps/desktop/src/i18n/locales/zh-TW.ts
index 822438a522..42978c3789 100644
--- a/apps/desktop/src/i18n/locales/zh-TW.ts
+++ b/apps/desktop/src/i18n/locales/zh-TW.ts
@@ -364,6 +364,43 @@ export default withEnglishFallback({
incomplete: "產生的 DDL 不完整,未複製。請開啟型別詳細資料查看警告。",
},
},
+ oracleType: {
+ kinds: { object: "物件型別", collection: "集合型別", other: "其他型別" },
+ source: "原始碼",
+ bodySource: "型別本體原始碼",
+ viewBody: "檢視型別本體",
+ methods: "方法",
+ methodMetadata: "方法中繼資料",
+ parameters: "參數",
+ results: "結果",
+ parameter: "參數",
+ result: "結果",
+ emptyMethods: "目前可見的字典結果中沒有方法記錄。",
+ emptyAttributes: "目前可見的字典結果中沒有屬性記錄。",
+ owner: "擁有者",
+ status: "狀態",
+ typeCode: "型別代碼",
+ isFinal: "不可繼承",
+ instantiable: "可建立執行個體",
+ supertype: "父型別",
+ attributeCount: "屬性數",
+ methodCount: "方法數",
+ bodyStatus: "型別本體狀態",
+ propertiesRead: "型別屬性讀取",
+ bodyRead: "型別本體配對讀取",
+ boolean: { yes: "是", no: "否" },
+ bodyVisibility: "型別本體可見性",
+ bodyVisible: "目前字典可見範圍內有型別本體",
+ bodyNotVisible: "目前字典可見範圍內沒有型別本體",
+ unknown: "未知",
+ body: "型別本體",
+ collection: "集合資訊",
+ upperBound: "上限",
+ length: "長度",
+ precision: "精度",
+ scale: "小數位數",
+ read: { available: "已載入", incomplete: "資訊不完整", unavailable: "無法使用或不可見", unsupported: "不支援" },
+ },
docs,
dataDictionary,
pluginPlatform: {
@@ -4873,6 +4910,57 @@ export default withEnglishFallback({
saveSource: "儲存",
cancelEdit: "取消",
sourceSaved: "原始碼已儲存",
+ typeManagementTitle: "型別變更",
+ typeManagementNonAtomic: "DDL 逐步提交。關閉預覽會保留原始碼頁籤中的草稿和執行記錄。",
+ typeManagementScope: "自動遷移僅涵蓋目前帳號可見的相依關係;不可見的跨帳號呼叫端可能失效。",
+ typeManagementDeleteSpec: "刪除規格也會刪除 TYPE BODY。必須先解除相依參照,不會自動刪除資料表。",
+ typeManagementDeleteBody: "僅刪除 TYPE BODY,規格保留;呼叫其方法的物件可能失效。",
+ typeManagementKeepDraft: "保留草稿",
+ typeManagementConfirm: "確認執行",
+ typeManagementStop: "停止後續步驟",
+ typeManagementResume: "檢視變更 / 接續",
+ typeManagementUseSave: "TYPE 原始碼請使用「預覽並儲存」,不要直接執行。",
+ typeManagementPreviewSave: "預覽並儲存",
+ typeManagementExistingDraft: "此物件有尚未完成的變更,正在接續原計畫。",
+ typeManagementCloseWarning: "關閉將遺失這些頁籤中的型別變更接續記錄。已執行的 DDL 與資料庫中的資料基準不會撤銷或刪除。",
+ typeManagementDiscardClose: "捨棄接續記錄並關閉",
+ typeManagementDeleted: "物件已刪除;原定義保留供參考。",
+ typeManagementRefreshFailed: "變更已寫入,但重新整理失敗:{message}。請重新讀取,不要重複執行。",
+ typeManagementRunningClose: "型別變更仍有陳述式執行中。請先在預覽中停止後續步驟,等候讀回結果後再關閉。",
+ typeManagementMaintenance: "已暫停受影響物件的業務寫入,並準備核對逐步執行的結果。",
+ typeDataTitle: "持久化資料對應",
+ typeDataInstructions: "先準備並提交永久 OLD/EXPECTED 純量資料表,設為資料庫原生唯讀。登記完整舊值後,再到 SQL 編輯器完成轉換並解除型別參照;返回核驗資料,最後重新驗證型別計畫。",
+ typeDataSource: "原資料表 / 欄位",
+ typeDataTarget: "目標資料表",
+ typeDataOwner: "Owner(精確)",
+ typeDataReadProjection: "讀取完整投影",
+ typeDataTargetPath: "目標欄位路徑(JSON)",
+ typeDataUnchanged: "保持原值",
+ typeDataPrepareHint: "OLD 必須保留原資料表全部受保護值,EXPECTED 描述全部目標值。保持原值的欄位會完整比較;不支援增刪列或彙總。",
+ typeDataPrepareSql: "在 SQL 編輯器查看原投影",
+ typeDataRegister: "登記並儲存原基準",
+ typeDataVerified: "目標完整資料已核實;重新驗證後可繼續型別步驟。",
+ typeDataWaiting: "等待轉換、目標資料核驗及解除型別參照。",
+ typeDataIntegrity: "基準身分與完整性",
+ typeDataBoundedInsert: "受限純量 INSERT",
+ typeDataInsertHint: "僅支援從登記 EXPECTED 向登記空純量資料表執行一條明確欄位的 INSERT SELECT。不接受函式、篩選、聯結及隱藏寫入入口;複雜轉換請在 SQL 編輯器完成後返回核驗。",
+ typeDataPreviewInsert: "預覽並驗證 INSERT",
+ typeDataRunInsert: "確認寫入純量目標",
+ typeDataVerify: "核驗原基準與目標資料",
+ typeDataKeepBaselines: "OLD/EXPECTED 和續作記錄均會保留。取消、失敗、關閉及成功均不會自動刪除基準。",
+ typeDataPathError: "目標欄位路徑必須是非空 JSON 字串陣列。",
+ typeManagementCurrentSource: "資料庫目前原始碼",
+ typeManagementNativeEvolution: "使用 Oracle 原生演進,原位保留資料,無需準備 OLD/EXPECTED。每步核對類型結構、相依性及資料表狀態。",
+ typeManagementPreviousAttempts: "先前的執行嘗試",
+ typeManagementDraftLabel: "待執行定義",
+ typeManagementValidationPending: "修正定義或相依性後,按「重新驗證」;通過後再確認執行。",
+ typeManagementState: {
+ "not-sent": "未傳送",
+ sent: "已傳送",
+ confirmed: "已核實",
+ failed: "失敗",
+ unknown: "結果未知",
+ },
sourceSaveFailed: "儲存原始碼失敗:{message}",
routineWritePending: "尚未確認原始請求已完成(作業 {operationId})。草稿已保留;再次儲存只會核對原始請求,不會重新送出。",
routineWriteUnverified: "尚未驗證儲存成功(作業 {operationId})。草稿已保留,請依下方結果處理。",
diff --git a/apps/desktop/src/lib/__tests__/database/databaseObjectCapabilities.spec.ts b/apps/desktop/src/lib/__tests__/database/databaseObjectCapabilities.spec.ts
index b7f3df8636..12adeb110a 100644
--- a/apps/desktop/src/lib/__tests__/database/databaseObjectCapabilities.spec.ts
+++ b/apps/desktop/src/lib/__tests__/database/databaseObjectCapabilities.spec.ts
@@ -5,6 +5,7 @@ import {
normalizeSidebarObjectKind,
schemaDiffRoutineObjectTypes,
schemaDiffRoutineObjectTypesIntersection,
+ supportsOracleFamilyTypeManagement,
sidebarObjectKindsForDatabase,
supportsPackageMemberExpansion,
supportsSchemaDiffRoutines,
@@ -32,6 +33,13 @@ describe("databaseObjectCapabilities", () => {
expect(sidebarObjectKindsForDatabase("dameng")).toEqual(expect.arrayContaining(["MATERIALIZED_VIEW", "SEQUENCE", "PACKAGE", "PACKAGE_BODY"]));
});
+ it.each(["oracle", "oceanbase-oracle", "dameng"] as const)("exposes %s types and bodies through the existing read-only browsing paths", (dbType) => {
+ expect(sidebarObjectKindsForDatabase(dbType)).toEqual(expect.arrayContaining(["TYPE", "TYPE_BODY"]));
+ expect(databaseObjectCapabilities(dbType).sourceReadable).toEqual(expect.arrayContaining(["TYPE", "TYPE_BODY"]));
+ expect(supportsTypeObjectSource(dbType)).toBe(true);
+ expect(customTypeCapabilities(dbType)).toEqual({ details: true, members: true, ddl: false });
+ });
+
it("exposes synonyms only for database paths with synonym metadata", () => {
expect(sidebarObjectKindsForDatabase("oracle")).toContain("SYNONYM");
expect(sidebarObjectKindsForDatabase("xugu")).toContain("SYNONYM");
@@ -42,8 +50,8 @@ describe("databaseObjectCapabilities", () => {
it("exposes OceanBase Oracle sequences and synonyms through the grouped object path", () => {
const oceanBaseObjects = sidebarObjectKindsForDatabase("oceanbase-oracle");
- expect(oceanBaseObjects).toEqual(["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "SEQUENCE", "INDEX", "SYNONYM", "PACKAGE", "PACKAGE_BODY"]);
- expect(databaseObjectCapabilities("oceanbase-oracle").sourceReadable).toEqual(["VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "SEQUENCE", "SYNONYM", "PACKAGE", "PACKAGE_BODY"]);
+ expect(oceanBaseObjects).toEqual(["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "SEQUENCE", "INDEX", "SYNONYM", "PACKAGE", "PACKAGE_BODY", "TYPE", "TYPE_BODY"]);
+ expect(databaseObjectCapabilities("oceanbase-oracle").sourceReadable).toEqual(["VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "SEQUENCE", "SYNONYM", "PACKAGE", "PACKAGE_BODY", "TYPE", "TYPE_BODY"]);
expect(
buildObjectGroupPlaceholderNodes({
nodeId: "connection:database:APP",
@@ -52,13 +60,13 @@ describe("databaseObjectCapabilities", () => {
schema: "APP",
objectTypes: oceanBaseObjects,
}).map((node) => node.type),
- ).toEqual(["group-tables", "group-views", "group-materialized-views", "group-procedures", "group-functions", "group-sequences", "group-database-indexes", "group-synonyms", "group-packages"]);
+ ).toEqual(["group-tables", "group-views", "group-materialized-views", "group-procedures", "group-functions", "group-sequences", "group-database-indexes", "group-synonyms", "group-packages", "group-types"]);
});
it("exposes Oracle sequences through the existing grouped object path", () => {
const oracleObjects = sidebarObjectKindsForDatabase("oracle");
- expect(oracleObjects).toEqual(["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "SEQUENCE", "INDEX", "SYNONYM", "PACKAGE", "PACKAGE_BODY"]);
+ expect(oracleObjects).toEqual(["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "SEQUENCE", "INDEX", "SYNONYM", "PACKAGE", "PACKAGE_BODY", "TYPE", "TYPE_BODY"]);
expect(databaseObjectCapabilities("oracle").sourceReadable).toContain("SEQUENCE");
expect(
buildObjectGroupPlaceholderNodes({
@@ -133,13 +141,26 @@ describe("databaseObjectCapabilities", () => {
}
});
- it("only Xugu TYPE nodes can open object source", () => {
+ it("opens Oracle-family and Xugu TYPE nodes as source while PG types keep details", () => {
expect(supportsTypeObjectSource("xugu")).toBe(true);
+ for (const dbType of ["oracle", "oceanbase-oracle", "dameng"] as const) {
+ expect(supportsTypeObjectSource(dbType)).toBe(true);
+ expect(databaseObjectCapabilities(dbType).sourceReadable).toEqual(expect.arrayContaining(["TYPE", "TYPE_BODY"]));
+ }
for (const dbType of ["postgres", "opengauss", "gaussdb", "kingbase", "vastbase", undefined] as const) {
expect(supportsTypeObjectSource(dbType), String(dbType)).toBe(false);
}
});
+ it("limits controlled type management to Oracle, OceanBase Oracle, and Dameng", () => {
+ for (const dbType of ["oracle", "oceanbase-oracle", "dameng"] as const) {
+ expect(supportsOracleFamilyTypeManagement(dbType), dbType).toBe(true);
+ }
+ for (const dbType of ["xugu", "postgres", "jdbc", undefined] as const) {
+ expect(supportsOracleFamilyTypeManagement(dbType), String(dbType)).toBe(false);
+ }
+ });
+
it("keeps sourceReadable in sync with supportsTypeObjectSource", () => {
expect(databaseObjectCapabilities("xugu").sourceReadable).toContain("TYPE");
expect(databaseObjectCapabilities("xugu").sourceReadable).toContain("TYPE_BODY");
diff --git a/apps/desktop/src/lib/__tests__/database/jdbcDialect.spec.ts b/apps/desktop/src/lib/__tests__/database/jdbcDialect.spec.ts
index 99beccefe3..47ae700495 100644
--- a/apps/desktop/src/lib/__tests__/database/jdbcDialect.spec.ts
+++ b/apps/desktop/src/lib/__tests__/database/jdbcDialect.spec.ts
@@ -38,6 +38,7 @@ import {
} from "@/lib/database/jdbcDialect";
import { supportsTransfer } from "@/lib/database/databaseFeatureSupport";
import { transferObjectKindsForDatabase } from "@/lib/database/transferObjectKinds";
+import { sidebarObjectKindsForDatabase } from "@/lib/database/databaseObjectCapabilities";
describe("Kingbase compatibility mode routing", () => {
it.each([undefined, "", "future_mode"])("does not infer a mode from a version, URL, or unknown mode (%s)", (mode) => {
@@ -201,6 +202,7 @@ describe("jdbc dialect inference", () => {
it.each([
["jdbc:oracle:thin:@//localhost:1521/XE", "oracle"],
["jdbc:dm://localhost:5236/DAMENG", "dameng"],
+ ["jdbc:oceanbase:oracle://localhost:2881/APP", "oceanbase-oracle"],
] as const)("uses connection-root schemas for %s", (connectionString, dialect) => {
const connection = {
db_type: "jdbc" as const,
@@ -214,6 +216,56 @@ describe("jdbc dialect inference", () => {
expect(connectionObjectTreeNodeSchema(connection, "DBX_TEST", "DBX_TEST")).toBe("DBX_TEST");
});
+ it("prioritizes explicit OceanBase Oracle mode over conflicting JDBC labels", () => {
+ const connection = {
+ db_type: "jdbc" as const,
+ connection_string: " JDBC:OceanBase:Oracle://localhost:2881/APP ",
+ driver_label: "OceanBase MySQL JDBC",
+ jdbc_driver_class: "com.oceanbase.jdbc.Driver",
+ };
+ expect(inferJdbcDialect(connection)).toBe("oceanbase-oracle");
+ expect(effectiveDatabaseTypeForConnection(connection)).toBe("oceanbase-oracle");
+ expect(connectionUsesConnectionRootSchemaMode(connection)).toBe(true);
+ });
+
+ it("keeps a protected JDBC URL unclassified when the safe connection DTO has no dialect identity", () => {
+ const safeConnection = {
+ db_type: "jdbc" as const,
+ driver_profile: "jdbc",
+ driver_label: "jdbc",
+ connection_string: "<protected>",
+ jdbc_driver_class: "custom.Driver",
+ jdbc_driver_paths: ["/drivers/custom.jar"],
+ };
+ const effectiveType = effectiveDatabaseTypeForConnection(safeConnection);
+
+ expect(inferJdbcDialect(safeConnection)).toBeUndefined();
+ expect(effectiveType).toBe("jdbc");
+ expect(connectionUsesConnectionRootSchemaMode(safeConnection)).toBe(false);
+ expect(sidebarObjectKindsForDatabase(effectiveType)).not.toContain("TYPE");
+ expect(sidebarObjectKindsForDatabase(effectiveType)).not.toContain("TYPE_BODY");
+ });
+
+ it("uses an approved dialect hint only for protected saved JDBC URLs", () => {
+ const protectedConnection = {
+ db_type: "jdbc" as const,
+ connection_string: "__DBX_SAVED_CREDENTIAL__:opaque",
+ jdbc_dialect: "oceanbase-oracle" as const,
+ };
+ expect(effectiveDatabaseTypeForConnection(protectedConnection)).toBe("oceanbase-oracle");
+ expect(effectiveDatabaseTypeForConnection({ ...protectedConnection, connection_string: "jdbc:mysql://host/db" })).toBe("mysql");
+ expect(effectiveDatabaseTypeForConnection({ ...protectedConnection, connection_string: "" })).toBe("jdbc");
+ expect(effectiveDatabaseTypeForConnection({ ...protectedConnection, db_type: "oracle" })).toBe("oracle");
+ expect(effectiveDatabaseTypeForConnection({ ...protectedConnection, jdbc_dialect: "oracle" as never })).toBe("jdbc");
+ });
+
+ it("does not guess Oracle mode from an ordinary OceanBase URL or change MySQL connections", () => {
+ expect(inferJdbcDialect({ db_type: "jdbc", connection_string: "jdbc:oceanbase://localhost:2881/APP", jdbc_driver_class: "com.oceanbase.jdbc.Driver" })).toBeUndefined();
+ expect(effectiveDatabaseTypeForConnection({ db_type: "jdbc", connection_string: "jdbc:mysql://localhost:2881/APP", driver_label: "OceanBase" })).toBe("mysql");
+ expect(effectiveDatabaseTypeForConnection({ db_type: "mysql", driver_profile: "oceanbase" })).toBe("mysql");
+ expect(effectiveDatabaseTypeForConnection({ db_type: "oceanbase-oracle" })).toBe("oceanbase-oracle");
+ });
+
it("detects GaussDB-compatible JDBC connections as schema-aware", () => {
const gaussdbConnection = {
db_type: "jdbc" as const,
diff --git a/apps/desktop/src/lib/__tests__/sidebar/customTypeTree.spec.ts b/apps/desktop/src/lib/__tests__/sidebar/customTypeTree.spec.ts
index 238391dcca..1d3fd62e5a 100644
--- a/apps/desktop/src/lib/__tests__/sidebar/customTypeTree.spec.ts
+++ b/apps/desktop/src/lib/__tests__/sidebar/customTypeTree.spec.ts
@@ -45,6 +45,53 @@ describe("custom type sidebar tree", () => {
expect(children.map((child) => child.id)).toEqual(["c:db:app:types:status:type-member:enum-value:draft", "c:db:app:types:status:type-member:enum-value:published"]);
});
+ it("uses Oracle attributes instead of the empty PostgreSQL members field", () => {
+ const children = buildCustomTypeTreeChildren(
+ parent,
+ details({
+ kind: "object",
+ oracleMetadata: {
+ propertiesRead: { state: "available" },
+ bodyRead: { state: "unsupported" },
+ attributesRead: { state: "incomplete", reason: "Some rows were truncated." },
+ methodsRead: { state: "available" },
+ collectionRead: { state: "unsupported" },
+ attributes: [
+ { name: "amount", ordinal: 2, typeName: "NUMBER", precision: 12, scale: 3 },
+ { name: "label", ordinal: 1, typeName: "VARCHAR2", length: 40 },
+ ],
+ methods: [],
+ },
+ }),
+ );
+
+ expect(children.map((child) => child.meta)).toEqual([
+ { kind: "field", displayValue: "NUMBER(12, 3)", ordinal: 2 },
+ { kind: "field", displayValue: "VARCHAR2(40)", ordinal: 1 },
+ ]);
+ expect(children.map((child) => child.label)).toEqual(["amount", "label"]);
+ });
+
+ it.each(["unavailable", "unsupported"] as const)("does not expand Oracle attributes when they are %s", (state) => {
+ expect(
+ buildCustomTypeTreeChildren(
+ parent,
+ details({
+ kind: "object",
+ oracleMetadata: {
+ propertiesRead: { state: "available" },
+ bodyRead: { state: "unsupported" },
+ attributesRead: { state },
+ methodsRead: { state: "available" },
+ collectionRead: { state: "unsupported" },
+ attributes: [{ name: "amount", typeName: "NUMBER" }],
+ methods: [],
+ },
+ }),
+ ),
+ ).toEqual([]);
+ });
+
it("keeps existing member IDs stable when a new member is inserted", () => {
const before = buildCustomTypeTreeChildren(
parent,
diff --git a/apps/desktop/src/lib/__tests__/sidebar/sidebarTreeLabel.oracleTypes.spec.ts b/apps/desktop/src/lib/__tests__/sidebar/sidebarTreeLabel.oracleTypes.spec.ts
new file mode 100644
index 0000000000..ffac6a97c4
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sidebar/sidebarTreeLabel.oracleTypes.spec.ts
@@ -0,0 +1,14 @@
+import { describe, expect, it } from "vitest";
+import { sidebarTreeSecondaryValue } from "@/lib/sidebar/sidebarTreeLabel";
+import type { TreeNode } from "@/types/database";
+
+describe("sidebar tree labels", () => {
+ it("uses the same dialect-specific TYPE labels for rendering and width measurement", () => {
+ const node: TreeNode = { id: "type", type: "type", label: "T", customTypeKind: "object" };
+ const t = (key: string) => key;
+ expect(sidebarTreeSecondaryValue(node, t, "oracle")).toBe("oracleType.kinds.object");
+ expect(sidebarTreeSecondaryValue(node, t, "oceanbase-oracle")).toBe("oracleType.kinds.object");
+ expect(sidebarTreeSecondaryValue(node, t, "postgres")).toBe("customType.kinds.object");
+ expect(sidebarTreeSecondaryValue(node, t)).toBe("customType.kinds.object");
+ });
+});
diff --git a/apps/desktop/src/lib/__tests__/sidebar/treeNodeClick.spec.ts b/apps/desktop/src/lib/__tests__/sidebar/treeNodeClick.spec.ts
index decba9aa98..370b67534f 100644
--- a/apps/desktop/src/lib/__tests__/sidebar/treeNodeClick.spec.ts
+++ b/apps/desktop/src/lib/__tests__/sidebar/treeNodeClick.spec.ts
@@ -27,8 +27,13 @@ describe("treeNodeClick", () => {
expect(treeNodeRowAction("synonym", false)).toBe("open-source");
});
- it("only Xugu type nodes open source on single click", () => {
+ it("opens Oracle-family and Xugu type sources on single click", () => {
expect(treeNodeRowAction("type", false, "single", "xugu")).toBe("open-source");
+ for (const dbType of ["oracle", "oceanbase-oracle", "dameng"] as const) {
+ expect(treeNodeRowAction("type", false, "single", dbType), dbType).toBe("open-source");
+ expect(treeNodeRowAction("type-body", false, "single", dbType), dbType).toBe("open-source");
+ expect(treeNodeRowAction("type", true, "single", dbType), dbType).toBe("toggle");
+ }
for (const dbType of ["postgres", "opengauss", "gaussdb", "kingbase", "vastbase"] as const) {
expect(treeNodeRowAction("type", true, "single", dbType), String(dbType)).toBe("toggle");
expect(treeNodeRowAction("type", false, "single", dbType), String(dbType)).toBe("none");
@@ -37,8 +42,12 @@ describe("treeNodeClick", () => {
expect(treeNodeRowAction("type", false, "single", undefined)).toBe("none");
});
- it("only Xugu type nodes open source on double click", () => {
+ it("opens Oracle-family and Xugu type sources on double click", () => {
expect(treeNodeRowDoubleClickAction("type", false, "double", false, "xugu")).toBe("open-source");
+ for (const dbType of ["oracle", "oceanbase-oracle", "dameng"] as const) {
+ expect(treeNodeRowDoubleClickAction("type", false, "double", false, dbType), dbType).toBe("open-source");
+ expect(treeNodeRowDoubleClickAction("type-body", false, "double", false, dbType), dbType).toBe("open-source");
+ }
for (const dbType of ["postgres", "opengauss", "gaussdb", "kingbase", "vastbase"] as const) {
expect(treeNodeRowDoubleClickAction("type", false, "double", true, dbType), String(dbType)).toBe("toggle");
expect(treeNodeRowDoubleClickAction("type", false, "double", false, dbType), String(dbType)).toBe("none");
diff --git a/apps/desktop/src/lib/__tests__/table/objectBrowserRowAction.spec.ts b/apps/desktop/src/lib/__tests__/table/objectBrowserRowAction.spec.ts
index 306bee4ee9..648adc9358 100644
--- a/apps/desktop/src/lib/__tests__/table/objectBrowserRowAction.spec.ts
+++ b/apps/desktop/src/lib/__tests__/table/objectBrowserRowAction.spec.ts
@@ -43,10 +43,15 @@ describe("singleClickRowAction", () => {
expect(singleClickRowAction(row(type, "programmable_test"), "xugu")).toBe("open-source");
});
- it("only Xugu TYPE rows open source", () => {
+ it("routes Oracle-family TYPE to details and TYPE_BODY to read-only source", () => {
expect(singleClickRowAction(row("TYPE", "app_status"), "xugu")).toBe("open-source");
expect(doubleClickRowAction(row("TYPE", "app_status"), "xugu")).toBe("open-source");
expect(singleClickRowAction(row("TYPE_BODY", "app_status"), "xugu")).toBe("open-source");
+ for (const dbType of ["oracle", "oceanbase-oracle", "dameng"] as const) {
+ expect(singleClickRowAction(row("TYPE", "app_status"), dbType), dbType).toBe("type-info");
+ expect(doubleClickRowAction(row("TYPE", "app_status"), dbType), dbType).toBe("type-info");
+ expect(singleClickRowAction(row("TYPE_BODY", "app_status"), dbType), dbType).toBe("open-source");
+ }
for (const dbType of ["postgres", "opengauss", "gaussdb", "kingbase", "vastbase"] as const) {
// Verified PG-family TYPE rows open the read-only details panel.
expect(singleClickRowAction(row("TYPE", "app_status"), dbType), String(dbType)).toBe("type-info");
diff --git a/apps/desktop/src/lib/__tests__/table/oracleTypeDataMapping.spec.ts b/apps/desktop/src/lib/__tests__/table/oracleTypeDataMapping.spec.ts
new file mode 100644
index 0000000000..b130ca0c1f
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/table/oracleTypeDataMapping.spec.ts
@@ -0,0 +1,244 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import * as api from "@/lib/backend/api";
+import { executeOracleTypeDataInsert, prepareOracleTypeDataInsert, verifyOracleTypeDataMappings } from "@/lib/table/oracleTypeDataMapping";
+import { executeOracleTypeManagement, prepareOracleTypeManagement, registerOracleTypeDataMapping, restoreOracleTypeManagementDraft, type OracleTypeManagementDraft, type TypeManagementTarget } from "@/lib/table/oracleTypeManagement";
+import type { OracleTypeDataBaseline, OracleTypeDataManifest, OracleTypeDataMappingInput, OracleTypeManagementSnapshot } from "@/types/database";
+
+vi.mock("@/lib/backend/api", () => ({ getOracleTypeManagementSnapshot: vi.fn(), buildOracleTypeManagementSql: vi.fn(), executeQuery: vi.fn(), executeConditionalUpdate: vi.fn(), verifyOracleTypeData: vi.fn() }));
+const target: TypeManagementTarget = { connectionId: "mapping-test", database: "db", owner: "APP", name: "ROOT", databaseType: "oceanbase-oracle" };
+const read = { state: "available" as const };
+const copy = <T>(value: T): T => JSON.parse(JSON.stringify(value));
+const original = 'CREATE OR REPLACE TYPE "APP"."ROOT" AS OBJECT (ID NUMBER);';
+const changed = 'CREATE OR REPLACE TYPE "APP"."ROOT" AS OBJECT (ID NUMBER, LABEL VARCHAR2(40));';
+const relation = (name: string) => ({ owner: "APP", name });
+const mapping: OracleTypeDataMappingInput = {
+ id: "permanent-original",
+ source: relation("SRC"),
+ old: relation("OLD"),
+ expected: relation("EXPECTED"),
+ target: relation("RESULT"),
+ fields: [{ sourcePath: ["ID"], objectNull: false, oldColumn: "ID", expectedColumn: "ID", targetPath: ["ID"], unchanged: true }],
+};
+function baseline(name: string, rows: number, readonly: boolean): OracleTypeDataBaseline {
+ return { relation: { relation: relation(name), objectId: `9007199254740993-${name}`, readOnly: readonly, structure: `metadata-${name}`, projection: [{ path: ["ID"], objectNull: false, dataType: "NUMBER(38,0)" }] }, rowCount: rows, fingerprint: "a".repeat(64) };
+}
+function manifest(): OracleTypeDataManifest {
+ return { mapping: copy(mapping), original: baseline("SRC", 3, false), old: baseline("OLD", 3, true), expected: baseline("EXPECTED", 3, true), preparedTarget: null, verifiedTarget: null };
+}
+function snapshot(): OracleTypeManagementSnapshot {
+ return {
+ target,
+ visibilityScope: "current-user-visible-dictionaries",
+ actingUser: "APP",
+ actingUserRead: read,
+ detailsRead: read,
+ typeSource: original,
+ typeSourceRead: read,
+ bodySource: null,
+ bodySourceRead: read,
+ objects: [
+ { owner: "APP", name: "ROOT", objectType: "TYPE", exists: true, objectId: "root-id", status: "VALID", source: original, sourceFingerprint: original, sourceRead: read, statusRead: read, errors: [], errorsRead: read, directPrivileges: [], privilegesRead: read },
+ { owner: "APP", name: "ROOT", objectType: "TYPE BODY", exists: false, objectId: null, status: null, source: null, sourceFingerprint: null, sourceRead: read, statusRead: read, errors: [], errorsRead: read, directPrivileges: [], privilegesRead: { state: "unsupported" } },
+ {
+ owner: "APP",
+ name: "SRC",
+ objectType: "TABLE",
+ exists: true,
+ objectId: baseline("SRC", 3, false).relation.objectId,
+ status: "VALID",
+ source: null,
+ sourceRead: { state: "unsupported" },
+ statusRead: read,
+ errors: [],
+ errorsRead: { state: "unsupported" },
+ directPrivileges: [],
+ privilegesRead: { state: "unsupported" },
+ },
+ ],
+ dependencies: [{ owner: "APP", name: "SRC", objectType: "TABLE", referencedOwner: "APP", referencedName: "ROOT", referencedType: "TYPE" }],
+ dependenciesRead: read,
+ persistentReferences: [{ owner: "APP", tableName: "SRC", columnName: "VALUE", dataTypeOwner: "APP", dataType: "ROOT" }],
+ persistentReferencesRead: read,
+ directPrivileges: [],
+ privilegesRead: read,
+ };
+}
+let actual: OracleTypeManagementSnapshot;
+let targetFilled: boolean;
+let verifyFailure: boolean;
+let baselineChanged: boolean;
+const sql = 'INSERT INTO "APP"."RESULT" ("ID") SELECT "ID" FROM "APP"."EXPECTED";';
+beforeEach(() => {
+ vi.clearAllMocks();
+ actual = snapshot();
+ targetFilled = false;
+ verifyFailure = false;
+ baselineChanged = false;
+ vi.mocked(api.getOracleTypeManagementSnapshot).mockImplementation(async () => copy(actual));
+ vi.mocked(api.buildOracleTypeManagementSql).mockImplementation(async (input) => ({ statements: [input.source!], sourceFingerprint: input.source }));
+ vi.mocked(api.verifyOracleTypeData).mockImplementation(async (input) => {
+ if (input.action === "register") return { manifest: manifest() };
+ const record = copy(input.manifest!);
+ if (baselineChanged) record.old.fingerprint = "b".repeat(64);
+ if (input.action === "validate_insert") {
+ if (targetFilled) throw new Error("Target is not empty");
+ record.preparedTarget = baseline("RESULT", 0, false);
+ return { manifest: record, insertSql: sql };
+ }
+ if (verifyFailure || !targetFilled) throw new Error("Actual target does not match the complete EXPECTED relation");
+ record.verifiedTarget = baseline("RESULT", 3, false);
+ // SQLite JSON storage and Rust serialization need not retain property order.
+ record.mapping.source = { name: record.mapping.source.name, owner: record.mapping.source.owner };
+ return { manifest: record };
+ });
+ vi.mocked(api.executeQuery).mockImplementation(async (_connection, _database, statement) => {
+ if (statement === sql) targetFilled = true;
+ else {
+ actual.objects[0].source = actual.objects[0].sourceFingerprint = statement;
+ actual.typeSource = statement;
+ }
+ return { execution_error: false, messages: [], rows: [] } as never;
+ });
+ vi.mocked(api.executeConditionalUpdate).mockImplementation((...args) => api.executeQuery(...args));
+});
+async function registered(nextSource = changed): Promise<OracleTypeManagementDraft> {
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [{ owner: "APP", name: "ROOT", objectType: "TYPE", source: nextSource }]);
+ return registerOracleTypeDataMapping(plan, mapping, async () => {});
+}
+function unlink() {
+ actual.persistentReferences = [];
+ actual.dependencies = [];
+ actual.objects[2].exists = false;
+ actual.objects[2].objectId = null;
+}
+
+describe("durable TYPE data mapping and bounded execution", () => {
+ it("resumes a later BODY failure on another session with the original permanent baselines and no root replay", async () => {
+ const oldSpec = original.replace("ID NUMBER", "ID NUMBER, MEMBER FUNCTION F RETURN NUMBER");
+ const newSpec = changed.replace("LABEL VARCHAR2(40)", "LABEL VARCHAR2(40), MEMBER FUNCTION F RETURN NUMBER");
+ const body = 'CREATE OR REPLACE TYPE BODY "APP"."ROOT" AS MEMBER FUNCTION F RETURN NUMBER IS BEGIN RETURN 1; END; END;';
+ actual.typeSource = oldSpec;
+ actual.objects[0].source = actual.objects[0].sourceFingerprint = oldSpec;
+ Object.assign(actual.objects[1], { exists: true, objectId: "body-id", status: "VALID", source: body, sourceFingerprint: body });
+ let rejectBody = true;
+ vi.mocked(api.executeQuery).mockImplementation(async (_connection, _database, statement) => {
+ const index = statement.includes("TYPE BODY") ? 1 : 0;
+ actual.objects[index].source = actual.objects[index].sourceFingerprint = statement;
+ if (index === 0) {
+ actual.typeSource = statement;
+ actual.objects[1].status = "INVALID";
+ } else actual.objects[1].status = rejectBody ? "INVALID" : "VALID";
+ return { execution_error: false, messages: [], rows: [] } as never;
+ });
+ const record = await registered(newSpec);
+ targetFilled = true;
+ unlink();
+ const plan = await prepareOracleTypeManagement(target, "save-spec", record.drafts, record);
+ await expect(executeOracleTypeManagement(plan, { persist: async () => {} })).rejects.toThrow("INVALID");
+ expect(plan.steps[0].state).toBe("confirmed");
+ const persisted = copy(plan);
+ const restored = restoreOracleTypeManagementDraft(persisted)!;
+ const repaired = restored.drafts.map((draft) => (draft.objectType === "TYPE BODY" ? { ...draft, source: body.replace("RETURN 1", "RETURN 2") } : draft));
+ rejectBody = false;
+ const next = await prepareOracleTypeManagement(target, "save-spec", repaired, restored);
+ expect(next.issues).toEqual([]);
+ const writes = vi.mocked(api.executeQuery).mock.calls.length;
+ await executeOracleTypeManagement(next, { persist: async () => {} });
+ expect(next.state).toBe("complete");
+ expect(
+ vi
+ .mocked(api.executeQuery)
+ .mock.calls.slice(writes)
+ .map((call) => call[2]),
+ ).toEqual([body.replace("RETURN 1", "RETURN 2")]);
+ expect(next.dataMappings[0].manifest.old).toEqual(record.dataMappings[0].manifest.old);
+ expect(next.dataMappings[0].manifest.expected).toEqual(record.dataMappings[0].manifest.expected);
+ });
+ it("registers while original data is live, saves the manifest and never replaces an existing baseline", async () => {
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [{ owner: "APP", name: "ROOT", objectType: "TYPE", source: changed }]);
+ const persist = vi.fn(async () => {});
+ const saved = await registerOracleTypeDataMapping(plan, mapping, persist);
+ expect(saved.dataMappings[0].manifest.old.fingerprint).toBe("a".repeat(64));
+ expect(persist).toHaveBeenCalledWith(saved);
+ expect(api.executeQuery).not.toHaveBeenCalled();
+ await expect(registerOracleTypeDataMapping(saved, mapping, persist)).rejects.toThrow("cannot be replaced");
+ expect(api.verifyOracleTypeData).toHaveBeenCalledTimes(1);
+ });
+ it("retains original baselines across restore and external preparation, then completes remaining TYPE steps", async () => {
+ const plan = await registered();
+ targetFilled = true;
+ unlink();
+ const restored = restoreOracleTypeManagementDraft(copy(plan))!;
+ expect(restored.executable).toBe(false);
+ const next = await prepareOracleTypeManagement(target, "save-spec", restored.drafts, restored);
+ expect(next.issues).toEqual([]);
+ expect(next.originalSnapshot.persistentReferences).toHaveLength(1);
+ expect(next.dataMappings[0].manifest.verifiedTarget?.rowCount).toBe(3);
+ const persist = vi.fn(async () => {});
+ await executeOracleTypeManagement(next, { persist });
+ expect(next.state).toBe("complete");
+ expect(api.executeQuery).toHaveBeenCalledOnce();
+ expect(api.verifyOracleTypeData).toHaveBeenCalledTimes(4); // registration, revalidation, pre-DDL and post-DDL
+ expect(next.dataMappings[0].manifest.old).toEqual(plan.dataMappings[0].manifest.old);
+ });
+ it("preserves the record and sends no TYPE SQL when the original baseline changes or references remain", async () => {
+ const plan = await registered();
+ targetFilled = true;
+ const withReferences = await prepareOracleTypeManagement(target, "save-spec", plan.drafts, plan);
+ expect(withReferences.executable).toBe(false);
+ expect(withReferences.issues.some((issue) => issue.code === "persistent-mapping")).toBe(true);
+ unlink();
+ baselineChanged = true;
+ const invalid = await prepareOracleTypeManagement(target, "save-spec", plan.drafts, plan);
+ expect(invalid.issues.some((issue) => issue.code === "persistent-data")).toBe(true);
+ expect(invalid.dataMappings[0].manifest.old.fingerprint).toBe("a".repeat(64));
+ expect(api.executeQuery).not.toHaveBeenCalled();
+ });
+ it("previews against the registered empty target, flushes sent state, and verifies all target values", async () => {
+ const plan = await registered();
+ const preview = await prepareOracleTypeDataInsert(plan, mapping.id, sql, async () => {});
+ expect(api.executeQuery).not.toHaveBeenCalled();
+ const persist = vi.fn(async (value: OracleTypeManagementDraft) => {
+ if (value.dataMappings[0].insertState === "sent") expect(api.executeQuery).not.toHaveBeenCalled();
+ });
+ await executeOracleTypeDataInsert(preview, mapping.id, { persist });
+ expect(preview.dataMappings[0].insertState).toBe("confirmed");
+ expect(api.executeQuery).toHaveBeenCalledWith(target.connectionId, target.database, sql, "APP");
+ expect(preview.dataMappings[0].manifest.old).toEqual(plan.dataMappings[0].manifest.old);
+ });
+ it("does not insert if persistence or confirmation fails", async () => {
+ const plan = await registered();
+ const preview = await prepareOracleTypeDataInsert(plan, mapping.id, sql, async () => {});
+ await expect(
+ executeOracleTypeDataInsert(preview, mapping.id, {
+ persist: async () => {
+ throw new Error("SQLite unavailable");
+ },
+ }),
+ ).rejects.toThrow("SQLite unavailable");
+ expect(preview.dataMappings[0].insertState).toBe("not-sent");
+ let current = true;
+ await expect(
+ executeOracleTypeDataInsert(preview, mapping.id, {
+ persist: async () => {
+ current = false;
+ },
+ isCurrent: () => current,
+ }),
+ ).rejects.toThrow("changed before dispatch");
+ expect(api.executeQuery).not.toHaveBeenCalled();
+ });
+ it("reconciles an unknown INSERT from the original durable manifest without replay", async () => {
+ const plan = await registered();
+ const preview = await prepareOracleTypeDataInsert(plan, mapping.id, sql, async () => {});
+ vi.mocked(api.executeQuery).mockRejectedValue(new Error("Lost response"));
+ await expect(executeOracleTypeDataInsert(preview, mapping.id, { persist: async () => {} })).rejects.toThrow("Lost response");
+ expect(preview.dataMappings[0].insertState).toBe("unknown");
+ const restored = restoreOracleTypeManagementDraft(copy(preview))!;
+ await expect(executeOracleTypeDataInsert(restored, mapping.id, { persist: async () => {} })).rejects.toThrow("Preview");
+ targetFilled = true;
+ await verifyOracleTypeDataMappings(restored);
+ expect(restored.dataMappings[0].insertState).toBe("confirmed");
+ expect(api.executeQuery).toHaveBeenCalledOnce();
+ });
+});
diff --git a/apps/desktop/src/lib/__tests__/table/oracleTypeEvolution.spec.ts b/apps/desktop/src/lib/__tests__/table/oracleTypeEvolution.spec.ts
new file mode 100644
index 0000000000..4bd51f0a64
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/table/oracleTypeEvolution.spec.ts
@@ -0,0 +1,177 @@
+import { beforeEach, expect, it, vi } from "vitest";
+import * as api from "@/lib/backend/api";
+import { executeOracleTypeManagement, prepareOracleTypeManagement, restoreOracleTypeManagementDraft, type TypeManagementTarget } from "@/lib/table/oracleTypeManagement";
+import type { OracleTypeEvolutionManifest, OracleTypeManagementObject, OracleTypeManagementSnapshot } from "@/types/database";
+
+vi.mock("@/lib/backend/api", () => ({ getOracleTypeManagementSnapshot: vi.fn(), buildOracleTypeManagementSql: vi.fn(), prepareOracleTypeEvolution: vi.fn(), executeConditionalUpdate: vi.fn(), cancelConditionalUpdate: vi.fn() }));
+const target: TypeManagementTarget = { connectionId: "native-evolution", database: "db", owner: "APP", name: "ROOT", databaseType: "oracle" };
+const before = 'CREATE OR REPLACE TYPE "APP"."ROOT" AS OBJECT (ID NUMBER(8,0), MEMBER FUNCTION F RETURN NUMBER);';
+const after = 'CREATE OR REPLACE TYPE "APP"."ROOT" AS OBJECT (ID NUMBER(10,0), LABEL VARCHAR2(40 BYTE), MEMBER FUNCTION F RETURN NUMBER);';
+const body = 'CREATE OR REPLACE TYPE BODY "APP"."ROOT" AS MEMBER FUNCTION F RETURN NUMBER IS BEGIN RETURN SELF.ID; END; END;';
+const dependent = 'CREATE OR REPLACE TYPE "APP"."COLL" AS TABLE OF "APP"."ROOT";';
+const statements = ['ALTER TYPE "APP"."ROOT" MODIFY ATTRIBUTE ("ID" NUMBER(10,0)) CASCADE INCLUDING TABLE DATA;', 'ALTER TYPE "APP"."ROOT" ADD ATTRIBUTE ("LABEL" VARCHAR2(40 BYTE)) CASCADE INCLUDING TABLE DATA;'];
+const available = { state: "available" as const };
+const copy = <T>(value: T): T => JSON.parse(JSON.stringify(value));
+let phase: number;
+let source: string;
+let metadata: string;
+let failAfter: boolean;
+let writes: string[];
+let pairedBody: string | undefined;
+let bodyValid: boolean;
+let dependentType: boolean;
+
+function snapshot(): OracleTypeManagementSnapshot {
+ const object = (name: string, objectType: string, text: string | null, objectId: string): OracleTypeManagementObject => ({
+ owner: "APP",
+ name,
+ objectType,
+ exists: true,
+ objectId,
+ status: "VALID",
+ statusRead: available,
+ source: text,
+ sourceFingerprint: text,
+ sourceRead: text ? available : { state: "unsupported" },
+ errors: [],
+ errorsRead: available,
+ directPrivileges: [],
+ privilegesRead: objectType === "TYPE" ? available : { state: "unsupported" },
+ });
+ const value: OracleTypeManagementSnapshot = {
+ target,
+ visibilityScope: "current-user-visible-dictionaries",
+ actingUser: "APP",
+ actingUserRead: available,
+ detailsRead: available,
+ typeSource: source,
+ typeSourceRead: available,
+ bodySourceRead: available,
+ objects: [object("ROOT", "TYPE", source, "1001"), object("DATA", "TABLE", null, "1002")],
+ dependencies: [{ owner: "APP", name: "DATA", objectType: "TABLE", referencedOwner: "APP", referencedName: "ROOT", referencedType: "TYPE" }],
+ dependenciesRead: available,
+ persistentReferences: [{ owner: "APP", tableName: "DATA", columnName: "VALUE", dataTypeOwner: "APP", dataType: "ROOT", tableReadOnly: false }],
+ persistentReferencesRead: available,
+ directPrivileges: [],
+ privilegesRead: available,
+ };
+ if (pairedBody) {
+ value.objects.push({ ...object("ROOT", "TYPE BODY", pairedBody, "1004"), status: bodyValid ? "VALID" : "INVALID" });
+ value.dependencies.push({ owner: "APP", name: "ROOT", objectType: "TYPE BODY", referencedOwner: "APP", referencedName: "ROOT", referencedType: "TYPE" });
+ }
+ if (dependentType) {
+ value.objects.push({ ...object("COLL", "TYPE", dependent, "1003"), directPrivileges: [{ grantor: "OTHER_GRANTOR", grantee: "READER", privilege: "EXECUTE", grantable: false, hierarchy: false }] });
+ value.dependencies.push({ owner: "APP", name: "COLL", objectType: "TYPE", referencedOwner: "APP", referencedName: "ROOT", referencedType: "TYPE" });
+ }
+ return value;
+}
+
+beforeEach(() => {
+ vi.clearAllMocks();
+ vi.mocked(api.cancelConditionalUpdate).mockResolvedValue({ requested: false, terminal: true, databaseTerminal: true });
+ phase = 0;
+ source = before;
+ metadata = "exact identity, grants, restrictions and native row-count guards";
+ failAfter = false;
+ writes = [];
+ pairedBody = undefined;
+ bodyValid = true;
+ dependentType = false;
+ vi.mocked(api.getOracleTypeManagementSnapshot).mockImplementation(async () => copy(snapshot()));
+ vi.mocked(api.prepareOracleTypeEvolution).mockImplementation(async (input): Promise<OracleTypeEvolutionManifest> => {
+ if (input.manifest && input.manifest.metadata !== metadata) throw new Error("Native evolution metadata changed");
+ return { target, sourceBefore: before, sourceAfter: after, statements, metadata, phase };
+ });
+ vi.mocked(api.buildOracleTypeManagementSql).mockImplementation(async (input) => ({ statements: [input.operation === "compile_spec" ? `ALTER TYPE "${input.owner}"."${input.name}" COMPILE SPECIFICATION;` : (input.source ?? "compile specification")], sourceFingerprint: input.source }));
+ vi.mocked(api.executeConditionalUpdate).mockImplementation(async (_id, _database, sql) => {
+ writes.push(sql);
+ if (sql.startsWith("CREATE OR REPLACE TYPE BODY")) {
+ pairedBody = sql;
+ bodyValid = !sql.includes("NO_SUCH_IDENTIFIER");
+ return { rows: [], messages: [] } as never;
+ }
+ if (sql === 'ALTER TYPE "APP"."COLL" COMPILE SPECIFICATION;') return { rows: [], messages: [] } as never;
+ if (sql !== statements[phase]) throw new Error("Unexpected or replayed native evolution SQL");
+ phase++;
+ source = phase === 1 ? 'CREATE TYPE "APP"."ROOT" AS OBJECT(ID NUMBER(10,0), MEMBER FUNCTION F RETURN NUMBER);' : 'CREATE TYPE "APP"."ROOT" AS OBJECT(ID NUMBER(10,0),LABEL VARCHAR2(40 BYTE), MEMBER FUNCTION F RETURN NUMBER);';
+ bodyValid = false;
+ if (failAfter) throw new Error("Lost native DDL response");
+ return { rows: [], messages: [] } as never;
+ });
+});
+
+it("uses Oracle native in-place evolution without demanding manual baselines or dropping the stored UDT table", async () => {
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [{ owner: "APP", name: "ROOT", objectType: "TYPE", source: after }]);
+ expect(plan.issues).toEqual([]);
+ expect(plan.dataMappings).toEqual([]);
+ expect(plan.steps.map((step) => step.sql)).toEqual(statements);
+ expect(api.executeConditionalUpdate).not.toHaveBeenCalled();
+ await executeOracleTypeManagement(plan, { persist: async () => {} });
+ expect(plan.state).toBe("complete");
+ expect(writes).toEqual(statements);
+ expect(plan.lastSnapshot.objects.find((object) => object.objectType === "TABLE")?.objectId).toBe("1002");
+});
+
+it("reconciles a lost native response by metadata and resumes only the remaining phase after durable reopening", async () => {
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [{ owner: "APP", name: "ROOT", objectType: "TYPE", source: after }]);
+ failAfter = true;
+ await expect(executeOracleTypeManagement(plan, { persist: async () => {}, shouldStop: () => phase >= 1 })).rejects.toThrow("Stopped");
+ expect(plan.steps[0].state).toBe("confirmed");
+ expect(plan.steps[1].state).toBe("not-sent");
+ const reopened = restoreOracleTypeManagementDraft(copy(plan))!;
+ const verified = await prepareOracleTypeManagement(target, "save-spec", reopened.drafts, reopened);
+ failAfter = false;
+ await executeOracleTypeManagement(verified, { persist: async () => {} });
+ expect(verified.state).toBe("complete");
+ expect(writes).toEqual(statements);
+});
+
+it("detects native guard changes before dispatch and never falls back to destructive source replacement", async () => {
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [{ owner: "APP", name: "ROOT", objectType: "TYPE", source: after }]);
+ metadata = "changed table identity or implicit index restriction";
+ await expect(executeOracleTypeManagement(plan, { persist: async () => {} })).rejects.toThrow("metadata changed");
+ expect(writes).toEqual([]);
+ expect(plan.executable).toBe(false);
+ expect(plan.requiresReverify).toBe(true);
+});
+
+it("keeps the manual repair route available when an unstarted native preview becomes inapplicable", async () => {
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [{ owner: "APP", name: "ROOT", objectType: "TYPE", source: after }]);
+ vi.mocked(api.prepareOracleTypeEvolution).mockRejectedValue(new Error("Unknown attribute index or storage restriction"));
+ const next = await prepareOracleTypeManagement(target, "save-spec", plan.drafts, plan);
+ expect(next.nativeEvolution).toBeUndefined();
+ expect(next.issues.map((issue) => issue.code)).toEqual(expect.arrayContaining(["native-evolution", "persistent-mapping"]));
+ expect(next.executable).toBe(false);
+ expect(next.drafts.find((draft) => draft.name === "ROOT")?.source).toBe(after);
+ expect(writes).toEqual([]);
+});
+
+it("repairs a failed BODY after native evolution without replaying either applied structural phase", async () => {
+ pairedBody = body;
+ const bad = body.replace("SELF.ID", "NO_SUCH_IDENTIFIER");
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [
+ { owner: "APP", name: "ROOT", objectType: "TYPE", source: after },
+ { owner: "APP", name: "ROOT", objectType: "TYPE BODY", source: bad },
+ ]);
+ await expect(executeOracleTypeManagement(plan, { persist: async () => {} })).rejects.toThrow("INVALID");
+ expect(plan.steps.filter((step) => step.kind === "evolve").every((step) => step.state === "confirmed")).toBe(true);
+ const previous = restoreOracleTypeManagementDraft(copy(plan))!;
+ const drafts = previous.drafts.map((draft) => ({ ...draft, source: draft.objectType === "TYPE BODY" ? body : draft.source }));
+ const next = await prepareOracleTypeManagement(target, "save-spec", drafts, previous);
+ expect(next.issues).toEqual([]);
+ await executeOracleTypeManagement(next, { persist: async () => {} });
+ expect(next.state).toBe("complete");
+ expect(writes).toEqual([...statements, bad, body]);
+ expect(next.history.some((step) => step.sql === bad && step.state === "failed")).toBe(true);
+});
+
+it("compiles unchanged dependent TYPE specifications and preserves grants without dropping or recreating them", async () => {
+ dependentType = true;
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [{ owner: "APP", name: "ROOT", objectType: "TYPE", source: after }]);
+ expect(plan.issues).toEqual([]);
+ expect(plan.steps.map((step) => step.kind)).toEqual(["evolve", "evolve", "compile"]);
+ await executeOracleTypeManagement(plan, { persist: async () => {} });
+ expect(writes).toEqual([...statements, 'ALTER TYPE "APP"."COLL" COMPILE SPECIFICATION;']);
+ expect(plan.lastSnapshot.objects.find((object) => object.name === "COLL")?.objectId).toBe("1003");
+ expect(plan.lastSnapshot.objects.find((object) => object.name === "COLL")?.directPrivileges[0].grantor).toBe("OTHER_GRANTOR");
+});
diff --git a/apps/desktop/src/lib/__tests__/table/oracleTypeManagement.spec.ts b/apps/desktop/src/lib/__tests__/table/oracleTypeManagement.spec.ts
new file mode 100644
index 0000000000..0d6f585291
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/table/oracleTypeManagement.spec.ts
@@ -0,0 +1,676 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import * as api from "@/lib/backend/api";
+import { BackendErrorException } from "@/lib/backend/errorUtils";
+import {
+ executeOracleTypeManagement,
+ OracleTypeManagementFailure,
+ prepareOracleTypeManagement,
+ restoreOracleTypeManagementDraft,
+ typeManagementObjectKey,
+ typeManagementSnapshotIdentity,
+ type OracleTypeManagementDraft,
+ type TypeManagementObjectDraft,
+ type TypeManagementTarget,
+} from "@/lib/table/oracleTypeManagement";
+import type { OracleTypeManagementDependency, OracleTypeManagementObject, OracleTypeManagementSnapshot, OracleTypeManagementSqlInput } from "@/types/database";
+
+vi.mock("@/lib/backend/api", () => ({ getOracleTypeManagementSnapshot: vi.fn(), buildOracleTypeManagementSql: vi.fn(), executeConditionalUpdate: vi.fn(), cancelConditionalUpdate: vi.fn() }));
+
+const target: TypeManagementTarget = { connectionId: "type-manager-test", database: "db", databaseType: "oceanbase-oracle", owner: "APP", name: "ROOT" };
+const available = { state: "available" as const };
+const json = <T>(value: T): T => JSON.parse(JSON.stringify(value));
+const key = (name: string, objectType = "TYPE", owner = "APP") => ({ owner, name, objectType });
+const identity = (name: string, objectType = "TYPE", owner = "APP") => typeManagementObjectKey(key(name, objectType, owner));
+const originalRoot = 'CREATE OR REPLACE TYPE "APP"."ROOT" AS OBJECT (ID NUMBER);';
+const changedRoot = 'CREATE OR REPLACE TYPE "APP"."ROOT" AS OBJECT (ID NUMBER, LABEL VARCHAR2(40));';
+const body = 'CREATE OR REPLACE TYPE BODY "APP"."ROOT" AS MEMBER FUNCTION GET_ID RETURN NUMBER AS BEGIN RETURN SELF.ID; END; END;';
+let objects: Map<string, OracleTypeManagementObject>;
+let edges: OracleTypeManagementDependency[];
+let statements: Map<string, OracleTypeManagementSqlInput>;
+let fault: ((input: OracleTypeManagementSqlInput) => "reject" | "invalid" | "network-before" | "network-after" | undefined) | undefined;
+let snapshotFault: ((snapshot: OracleTypeManagementSnapshot) => void) | undefined;
+let requests: string[];
+
+function object(name: string, objectType: string, source: string, objectId: string): OracleTypeManagementObject {
+ return { ...key(name, objectType), exists: true, objectId, status: "VALID", statusRead: available, source, sourceRead: available, sourceFingerprint: source, errors: [], errorsRead: available, directPrivileges: [], privilegesRead: objectType === "TYPE" ? available : { state: "unsupported" } };
+}
+
+function edge(name: string, type: string, referencedName: string, referencedType = "TYPE"): OracleTypeManagementDependency {
+ return { ...key(name, type), referencedOwner: "APP", referencedName, referencedType, referencedLink: null };
+}
+
+function snapshot(known: Array<{ owner: string; name: string; objectType: string }> = []): OracleTypeManagementSnapshot {
+ const states = [...objects.values()].map(json);
+ for (const item of [key("ROOT"), key("ROOT", "TYPE BODY"), ...known]) {
+ if (!states.some((candidate) => typeManagementObjectKey(candidate) === typeManagementObjectKey(item)))
+ states.push({
+ ...item,
+ exists: false,
+ objectId: null,
+ status: null,
+ statusRead: available,
+ source: null,
+ sourceRead: available,
+ sourceFingerprint: null,
+ errors: [],
+ errorsRead: available,
+ directPrivileges: [],
+ privilegesRead: item.objectType === "TYPE" ? available : { state: "unsupported" },
+ });
+ }
+ const value: OracleTypeManagementSnapshot = {
+ target: { connectionId: target.connectionId, database: target.database, owner: target.owner, name: target.name },
+ visibilityScope: "current-user-visible-dictionaries",
+ actingUser: "APP",
+ actingUserRead: available,
+ detailsRead: available,
+ typeSource: objects.get(identity("ROOT"))?.source,
+ typeSourceRead: available,
+ bodySource: objects.get(identity("ROOT", "TYPE BODY"))?.source,
+ bodySourceRead: available,
+ objects: states,
+ dependencies: edges.filter((item) => objects.has(typeManagementObjectKey(item)) && objects.has(identity(item.referencedName, item.referencedType))).map(json),
+ dependenciesRead: available,
+ persistentReferences: [],
+ persistentReferencesRead: available,
+ directPrivileges: objects.get(identity("ROOT"))?.directPrivileges ?? [],
+ privilegesRead: available,
+ };
+ snapshotFault?.(value);
+ return value;
+}
+
+function draft(name = "ROOT", source = changedRoot, objectType = "TYPE"): TypeManagementObjectDraft {
+ return { ...key(name, objectType), source };
+}
+
+function isolateRoot() {
+ for (const [id, item] of objects) if (item.name !== "ROOT") objects.delete(id);
+ edges = edges.filter((item) => item.name === "ROOT");
+}
+
+beforeEach(() => {
+ vi.clearAllMocks();
+ vi.mocked(api.cancelConditionalUpdate).mockResolvedValue({ requested: false, terminal: true, databaseTerminal: true });
+ requests = [];
+ statements = new Map();
+ fault = undefined;
+ snapshotFault = undefined;
+ objects = new Map([
+ [identity("ROOT"), object("ROOT", "TYPE", originalRoot, "9007199254740993")],
+ [identity("ROOT", "TYPE BODY"), object("ROOT", "TYPE BODY", body, "2")],
+ [identity("COLL"), object("COLL", "TYPE", 'CREATE OR REPLACE TYPE "APP"."COLL" AS TABLE OF "APP"."ROOT";', "3")],
+ [identity("DEEP"), object("DEEP", "TYPE", 'CREATE OR REPLACE TYPE "APP"."DEEP" AS TABLE OF "APP"."COLL";', "4")],
+ [identity("PROC", "PROCEDURE"), object("PROC", "PROCEDURE", 'CREATE OR REPLACE PROCEDURE "APP"."PROC" AS X "APP"."COLL"; BEGIN NULL; END;', "5")],
+ [identity("FN", "FUNCTION"), object("FN", "FUNCTION", 'CREATE OR REPLACE FUNCTION "APP"."FN" RETURN NUMBER AS X "APP"."ROOT"; BEGIN RETURN 1; END;', "6")],
+ ]);
+ objects.get(identity("COLL"))!.directPrivileges = [{ grantor: "APP", grantee: "OTHER", privilege: "EXECUTE", grantable: true, hierarchy: false }];
+ edges = [edge("ROOT", "TYPE BODY", "ROOT"), edge("COLL", "TYPE", "ROOT"), edge("DEEP", "TYPE", "COLL"), edge("PROC", "PROCEDURE", "COLL"), edge("FN", "FUNCTION", "ROOT")];
+ vi.mocked(api.getOracleTypeManagementSnapshot).mockImplementation(async (_connection, _database, _owner, _name, known) => snapshot(known));
+ vi.mocked(api.buildOracleTypeManagementSql).mockImplementation(async (input) => {
+ // External builder transport; declaration/tokenizer correctness is tested in dbx-sql-core.
+ if (input.source?.includes("BAD_DECLARATION")) throw new Error("Wrong declaration");
+ const sql =
+ input.source ?? `${input.operation === "drop_body" ? "DROP TYPE BODY" : input.operation === "drop_spec" ? "DROP TYPE" : `GRANT ${input.privilege ?? "EXECUTE"}`} "${input.owner}"."${input.name}"${input.grantee ? ` TO "${input.grantee}"${input.grantable ? " WITH GRANT OPTION" : ""}` : ""};`;
+ statements.set(sql, json(input));
+ return { statements: [sql], sourceFingerprint: input.source };
+ });
+ vi.mocked(api.executeConditionalUpdate).mockImplementation(async (_connection, _database, sql) => {
+ requests.push(sql);
+ const input = statements.get(sql)!;
+ if (!input) throw new Error("Unexpected SQL");
+ const failure = fault?.(input);
+ if (failure === "network-before") throw new Error("Network response is unknown");
+ if (failure === "reject") return { execution_error: true, error: "Rejected by database", messages: [], rows: [] } as never;
+ const kind = input.objectType?.replaceAll("_", " ") ?? (input.operation === "save_body" || input.operation === "drop_body" ? "TYPE BODY" : "TYPE");
+ const objectKey = identity(input.name, kind, input.owner);
+ if (input.operation === "drop_spec" || input.operation === "drop_body") {
+ objects.delete(objectKey);
+ if (kind === "TYPE") objects.delete(identity(input.name, "TYPE BODY", input.owner));
+ } else if (input.operation === "grant_privilege") {
+ const actual = objects.get(objectKey)!;
+ const grant = { grantor: input.owner, grantee: input.grantee!, privilege: input.privilege!, grantable: input.grantable!, hierarchy: false };
+ if (!actual.directPrivileges.some((item) => JSON.stringify(item) === JSON.stringify(grant))) actual.directPrivileges.push(grant);
+ } else if (input.operation === "compile_trigger") {
+ objects.get(objectKey)!.status = failure === "invalid" ? "INVALID" : "VALID";
+ } else {
+ const old = objects.get(objectKey);
+ const actual = { ...object(input.name, kind, input.source!, old?.objectId ?? `new-${input.name}`), owner: input.owner, directPrivileges: old?.directPrivileges ?? [] };
+ if (kind === "TRIGGER") {
+ actual.triggerEnabled = input.triggerEnabled ?? true;
+ actual.triggerEnabledRead = { ...available };
+ }
+ if (failure === "invalid") actual.status = "INVALID";
+ objects.set(objectKey, actual);
+ if (input.operation === "save_spec") {
+ const paired = objects.get(identity(input.name, "TYPE BODY", input.owner));
+ if (paired) paired.status = "INVALID";
+ }
+ // A replacement definition which no longer mentions ROOT removes that edge.
+ if (input.name !== "ROOT" && !input.source?.includes('"ROOT"')) edges = edges.filter((item) => !(typeManagementObjectKey(item) === objectKey && item.referencedName === "ROOT"));
+ }
+ if (failure === "network-after") throw new Error("Lost response after applying DDL");
+ return { execution_error: false, error: null, messages: [], rows: [] } as never;
+ });
+});
+
+describe("controlled TYPE plans", () => {
+ it.each([false, true])("preserves trigger enabled=%s through failed rebuild, durable reopen and repair", async (enabled) => {
+ isolateRoot();
+ const source = 'CREATE OR REPLACE TRIGGER "APP"."TRG" BEFORE INSERT ON "APP"."DATA" FOR EACH ROW BEGIN DECLARE X "APP"."ROOT"; BEGIN NULL; END; END;';
+ const trigger = { ...object("TRG", "TRIGGER", source, "7"), triggerEnabled: enabled, triggerEnabledRead: available };
+ objects.set(identity("TRG", "TRIGGER"), trigger);
+ edges.push(edge("TRG", "TRIGGER", "ROOT"));
+ fault = (input) => (input.objectType === "TRIGGER" ? "invalid" : undefined);
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [draft()]);
+ const triggerStep = plan.steps.find((step) => step.object.objectType === "TRIGGER")!;
+ expect(statements.get(triggerStep.sql)?.triggerEnabled).toBe(enabled);
+ const saved: OracleTypeManagementDraft[] = [];
+ await expect(
+ executeOracleTypeManagement(plan, {
+ persist: async (value) => {
+ saved.push(json(value));
+ },
+ }),
+ ).rejects.toThrow("INVALID");
+ expect(objects.get(identity("TRG", "TRIGGER"))?.triggerEnabled).toBe(enabled);
+ const beforeResume = requests.length;
+ fault = undefined;
+ const reopened = restoreOracleTypeManagementDraft(saved.at(-1))!;
+ const repaired = source.replace("NULL; END; END;", "NULL; NULL; END; END;");
+ const remaining = await prepareOracleTypeManagement(
+ target,
+ "save-spec",
+ reopened.drafts.map((item) => (item.objectType === "TRIGGER" ? { ...item, source: repaired } : item)),
+ reopened,
+ );
+ expect(remaining.issues).toEqual([]);
+ await executeOracleTypeManagement(remaining, { persist: async () => {} });
+ expect(requests.slice(beforeResume)).toEqual([remaining.steps.find((step) => step.object.objectType === "TRIGGER")!.sql]);
+ expect(objects.get(identity("TRG", "TRIGGER"))?.triggerEnabled).toBe(enabled);
+ });
+
+ it("blocks an unknown or concurrently changed trigger state before any TYPE write", async () => {
+ isolateRoot();
+ const source = 'CREATE TRIGGER "APP"."TRG" BEFORE INSERT ON "APP"."DATA" BEGIN NULL; END;';
+ const trigger = { ...object("TRG", "TRIGGER", source, "7"), triggerEnabled: false as boolean | null, triggerEnabledRead: { ...available } as { state: "available" | "incomplete" } };
+ objects.set(identity("TRG", "TRIGGER"), trigger);
+ edges.push(edge("TRG", "TRIGGER", "ROOT"));
+ trigger.triggerEnabled = null;
+ trigger.triggerEnabledRead.state = "incomplete";
+ expect((await prepareOracleTypeManagement(target, "save-spec", [draft()])).executable).toBe(false);
+ trigger.triggerEnabled = false;
+ trigger.triggerEnabledRead.state = "available";
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [draft()]);
+ trigger.triggerEnabled = true;
+ await expect(executeOracleTypeManagement(plan, { persist: async () => {} })).rejects.toThrow("changed");
+ expect(requests).toEqual([]);
+ });
+
+ it("keeps an unexpected trigger enablement unknown instead of confirming or replaying it", async () => {
+ isolateRoot();
+ const source = 'CREATE TRIGGER "APP"."TRG" BEFORE INSERT ON "APP"."DATA" BEGIN NULL; END;';
+ objects.set(identity("TRG", "TRIGGER"), { ...object("TRG", "TRIGGER", source, "7"), triggerEnabled: false, triggerEnabledRead: { ...available } });
+ edges.push(edge("TRG", "TRIGGER", "ROOT"));
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [draft()]);
+ const execute = vi.mocked(api.executeConditionalUpdate).getMockImplementation()!;
+ vi.mocked(api.executeConditionalUpdate).mockImplementation(async (...args) => {
+ const result = await execute(...args);
+ if (statements.get(args[2])?.objectType === "TRIGGER") objects.get(identity("TRG", "TRIGGER"))!.triggerEnabled = true;
+ return result;
+ });
+ await expect(executeOracleTypeManagement(plan, { persist: async () => {} })).rejects.toThrow("not been verified");
+ expect(plan.steps.find((step) => step.object.objectType === "TRIGGER")?.state).toBe("unknown");
+ const sent = requests.length;
+ const rechecked = await prepareOracleTypeManagement(target, "save-spec", plan.drafts, restoreOracleTypeManagementDraft(json(plan)));
+ expect(rechecked.executable).toBe(false);
+ expect(requests).toHaveLength(sent);
+ });
+
+ it("previews the transitive closure, reverse drops, paired BODY, forward rebuilds and grant options without executing", async () => {
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [draft()]);
+ expect(plan.issues).toEqual([]);
+ expect(plan.executable).toBe(true);
+ expect(plan.steps.filter((step) => step.kind === "drop-dependent").map((step) => step.object.name)).toEqual(["DEEP", "COLL"]);
+ const positions = (kind: string, name: string) => plan.steps.findIndex((step) => step.kind === kind && step.object.name === name);
+ expect(positions("replace", "ROOT")).toBeLessThan(positions("rebuild", "COLL"));
+ expect(positions("rebuild", "COLL")).toBeLessThan(positions("grant", "COLL"));
+ expect(positions("grant", "COLL")).toBeLessThan(positions("rebuild", "PROC"));
+ expect(plan.steps.find((step) => step.kind === "grant")?.sql).toContain("WITH GRANT OPTION");
+ expect(plan.steps.some((step) => /\bFORCE\b/.test(step.sql))).toBe(false);
+ expect(api.executeConditionalUpdate).not.toHaveBeenCalled();
+ });
+
+ it("keeps same-name kinds and case-sensitive owners distinct", () => {
+ expect(identity("Mixed Type")).not.toBe(identity("MIXED TYPE"));
+ expect(identity("ROOT")).not.toBe(identity("ROOT", "TYPE BODY"));
+ expect(identity("ROOT", "TYPE", "App")).not.toBe(identity("ROOT", "TYPE", "APP"));
+ });
+
+ it.each(["oracle", "oceanbase-oracle", "dameng"] as const)("uses the native %s builder for the same no-data closure", async (databaseType) => {
+ const plan = await prepareOracleTypeManagement({ ...target, databaseType }, "save-spec", [draft()]);
+ expect(plan.executable).toBe(true);
+ expect(vi.mocked(api.buildOracleTypeManagementSql).mock.calls.every(([input]) => input.databaseType === databaseType)).toBe(true);
+ expect(plan.steps.some((step) => /ALTER TYPE|COMPILE/.test(step.sql))).toBe(false);
+ });
+
+ it("retains generated work and editable definitions when metadata or one definition needs repair", async () => {
+ objects.get(identity("FN", "FUNCTION"))!.source = null;
+ objects.get(identity("FN", "FUNCTION"))!.sourceRead = { state: "unavailable", reason: "Source permission missing" };
+ snapshotFault = (value) => {
+ value.dependenciesRead = { state: "incomplete", reason: "Truncated" };
+ };
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [draft("COLL", "BAD_DECLARATION")]);
+ expect(plan.executable).toBe(false);
+ expect(plan.issues.map((issue) => issue.code)).toContain("invalid-definition");
+ expect(plan.issues.map((issue) => issue.code)).toContain("incomplete-metadata");
+ expect(plan.drafts.find((item) => item.name === "COLL")?.source).toBe("BAD_DECLARATION");
+ expect(plan.drafts.find((item) => item.name === "FN")?.source).toBe("");
+ expect(plan.steps.length).toBeGreaterThan(2);
+ expect(api.executeConditionalUpdate).not.toHaveBeenCalled();
+ });
+
+ it("does not silently drop persistent values, unknown grants, remote edges, or cyclic dependencies", async () => {
+ objects.get(identity("COLL"))!.directPrivileges[0].grantor = "ORIGINAL_GRANTOR";
+ edges.push(edge("COLL", "TYPE", "DEEP"));
+ snapshotFault = (value) => {
+ value.persistentReferences.push({ owner: "APP", tableName: "DATA", columnName: "VALUE", dataType: "ROOT", dataTypeOwner: "APP", tableReadOnly: false });
+ value.dependencies.push({ ...edge("REMOTE", "PROCEDURE", "ROOT"), referencedLink: "REMOTE_DB" });
+ };
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [draft()]);
+ expect(plan.executable).toBe(false);
+ expect(plan.issues.map((issue) => issue.code)).toEqual(expect.arrayContaining(["persistent-mapping", "database-link", "dependency-cycle"]));
+ expect(plan.drafts.length).toBeGreaterThan(1);
+ });
+
+ it("requires editable unlink definitions for deletion and verifies real edges before the final DROP", async () => {
+ const initial = await prepareOracleTypeManagement(target, "delete-spec");
+ expect(initial.issues.filter((issue) => issue.code === "unlink-required")).toHaveLength(2);
+ const unlinks = initial.drafts.map((item) => ({ ...item, source: item.name === "ROOT" ? item.source : item.source.replaceAll('"ROOT"', '"ALTERNATE"') }));
+ const plan = await prepareOracleTypeManagement(target, "delete-spec", unlinks);
+ expect(plan.executable).toBe(true);
+ expect(plan.steps.at(-1)?.kind).toBe("delete");
+ await executeOracleTypeManagement(plan, { persist: async () => {} });
+ expect(objects.has(identity("ROOT"))).toBe(false);
+ expect(objects.has(identity("ROOT", "TYPE BODY"))).toBe(false);
+ expect(objects.get(identity("COLL"))?.source).toContain('"ALTERNATE"');
+ expect(objects.has(identity("PROC", "PROCEDURE"))).toBe(true);
+ });
+
+ it("deletes only the BODY while retaining the specification and its other dependents", async () => {
+ const plan = await prepareOracleTypeManagement(target, "delete-body");
+ expect(plan.steps).toHaveLength(1);
+ await executeOracleTypeManagement(plan, { persist: async () => {} });
+ expect(objects.has(identity("ROOT"))).toBe(true);
+ expect(objects.has(identity("ROOT", "TYPE BODY"))).toBe(false);
+ expect(objects.has(identity("COLL"))).toBe(true);
+ });
+});
+
+describe("TYPE execution, persistence and recovery", () => {
+ it.each([
+ { requested: false, terminal: false, databaseTerminal: false },
+ { requested: false, terminal: true, databaseTerminal: false },
+ { requested: false, terminal: true },
+ ])("keeps an INVALID execution active across repeated edited previews without database completion: %j", async (completion) => {
+ isolateRoot();
+ fault = () => "invalid";
+ const execute = vi.mocked(api.executeConditionalUpdate).getMockImplementation()!;
+ vi.mocked(api.executeConditionalUpdate).mockImplementation(async (...args) => {
+ await execute(...args);
+ throw new Error("Lost INVALID response");
+ });
+ vi.mocked(api.cancelConditionalUpdate).mockResolvedValue(completion);
+ const plan = await prepareOracleTypeManagement(target, "save-body", [draft("ROOT", body, "TYPE BODY")]);
+ const saved: OracleTypeManagementDraft[] = [];
+ await expect(
+ executeOracleTypeManagement(plan, {
+ persist: async (value) => {
+ saved.push(json(value));
+ },
+ }),
+ ).rejects.toThrow("Lost INVALID response");
+ const sent = saved.find((record) => record.steps[0].state === "sent")!;
+ expect(sent.steps[0].executionId).toBeTruthy();
+ expect(api.executeConditionalUpdate).toHaveBeenCalledWith(target.connectionId, target.database, body, "APP", sent.steps[0].executionId, { typeRecovery: { planId: sent.planId, stepId: sent.steps[0].id } });
+ let reopened = restoreOracleTypeManagementDraft(saved.at(-1))!;
+ for (const value of ["2", "3"]) {
+ const revised = [draft("ROOT", body.replace("RETURN SELF.ID", `RETURN ${value}`), "TYPE BODY")];
+ reopened = await prepareOracleTypeManagement(target, "save-body", revised, reopened);
+ expect(reopened.executable).toBe(false);
+ expect(reopened.issues.map((issue) => issue.code)).toContain("unknown-result");
+ expect(reopened.steps[0].executionId).toBe(sent.steps[0].executionId);
+ expect(reopened.steps[0].state).toBe("unknown");
+ expect(reopened.drafts).toEqual(revised);
+ await expect(executeOracleTypeManagement(reopened, { persist: async () => {} })).rejects.toThrow("Revalidate");
+ }
+ expect(api.executeConditionalUpdate).toHaveBeenCalledOnce();
+ for (const [id, options] of vi.mocked(api.cancelConditionalUpdate).mock.calls) {
+ expect(id).toBe(sent.steps[0].executionId);
+ expect(options).toEqual({ cancel: false, typeRecovery: { executionId: id, planId: sent.planId, stepId: sent.steps[0].id, connectionId: target.connectionId, database: target.database, schema: "APP", sql: body } });
+ }
+ });
+
+ it("restores the original binding after a lost response and confirms durable completion without resending", async () => {
+ isolateRoot();
+ const execute = vi.mocked(api.executeConditionalUpdate).getMockImplementation()!;
+ vi.mocked(api.executeConditionalUpdate).mockImplementation(async (...args) => {
+ await execute(...args);
+ throw new Error("Response lost before restart");
+ });
+ vi.mocked(api.cancelConditionalUpdate).mockResolvedValue({ requested: false, terminal: false, databaseTerminal: false });
+ const desired = body.replace("RETURN SELF.ID", "RETURN SELF.ID + 11");
+ const plan = await prepareOracleTypeManagement(target, "save-body", [draft("ROOT", desired, "TYPE BODY")]);
+ await expect(executeOracleTypeManagement(plan, { persist: async () => {} })).rejects.toThrow("Response lost");
+ const restored = restoreOracleTypeManagementDraft(json(plan))!;
+ vi.mocked(api.cancelConditionalUpdate).mockImplementation(async (id, options) => {
+ expect(options).toEqual({ cancel: false, typeRecovery: { executionId: id, planId: plan.planId, stepId: plan.steps[0].id, connectionId: target.connectionId, database: target.database, schema: "APP", sql: desired } });
+ return { requested: false, terminal: true, databaseTerminal: true };
+ });
+ const recovered = await prepareOracleTypeManagement(target, "save-body", restored.drafts, restored);
+ expect(recovered.state).toBe("complete");
+ expect(api.executeConditionalUpdate).toHaveBeenCalledOnce();
+ });
+
+ it("waits for the original completion before taking the snapshot that makes INVALID repairable", async () => {
+ isolateRoot();
+ fault = () => "network-before";
+ vi.mocked(api.cancelConditionalUpdate).mockResolvedValue({ requested: false, terminal: false, databaseTerminal: false });
+ const desired = body.replace("RETURN SELF.ID", "RETURN SELF.ID + 7");
+ const plan = await prepareOracleTypeManagement(target, "save-body", [draft("ROOT", desired, "TYPE BODY")]);
+ await expect(executeOracleTypeManagement(plan, { persist: async () => {} })).rejects.toThrow();
+ vi.mocked(api.cancelConditionalUpdate).mockImplementation(async () => {
+ const current = objects.get(identity("ROOT", "TYPE BODY"))!;
+ current.source = current.sourceFingerprint = desired;
+ current.status = "INVALID";
+ return { requested: false, terminal: true, databaseTerminal: true };
+ });
+ const rechecked = await prepareOracleTypeManagement(target, "save-body", plan.drafts, restoreOracleTypeManagementDraft(json(plan)));
+ expect(rechecked.executable).toBe(true);
+ expect(rechecked.issues).toEqual([]);
+ expect(rechecked.history[0]).toMatchObject({ state: "failed", databaseTerminal: true, executionId: plan.steps[0].executionId });
+ expect(rechecked.history[0].message).toContain("INVALID");
+ expect(rechecked.lastSnapshot.objects.find((item) => item.objectType === "TYPE BODY")?.status).toBe("INVALID");
+ expect(api.executeConditionalUpdate).toHaveBeenCalledOnce();
+ });
+
+ it("does not adopt a concurrent grant change as the baseline when an unknown result is rechecked repeatedly", async () => {
+ isolateRoot();
+ fault = () => "invalid";
+ const execute = vi.mocked(api.executeConditionalUpdate).getMockImplementation()!;
+ vi.mocked(api.executeConditionalUpdate).mockImplementation(async (...args) => {
+ await execute(...args);
+ throw new Error("Lost INVALID response");
+ });
+ vi.mocked(api.cancelConditionalUpdate).mockResolvedValue({ requested: false, terminal: false, databaseTerminal: false });
+ const desired = body.replace("RETURN SELF.ID", "RETURN SELF.ID + 6");
+ const plan = await prepareOracleTypeManagement(target, "save-body", [draft("ROOT", desired, "TYPE BODY")]);
+ await expect(executeOracleTypeManagement(plan, { persist: async () => {} })).rejects.toThrow();
+ const accepted = typeManagementSnapshotIdentity(plan.lastSnapshot);
+ objects.get(identity("ROOT"))!.directPrivileges = [{ grantor: "APP", grantee: "OTHER", privilege: "EXECUTE", grantable: true, hierarchy: false }];
+ vi.mocked(api.cancelConditionalUpdate).mockResolvedValue({ requested: false, terminal: true, databaseTerminal: true });
+ let previous = restoreOracleTypeManagementDraft(json(plan))!;
+ for (let attempt = 0; attempt < 3; attempt++) {
+ previous = await prepareOracleTypeManagement(target, "save-body", previous.drafts, previous);
+ expect(previous.executable).toBe(false);
+ expect(previous.steps[0].state).toBe("unknown");
+ expect(typeManagementSnapshotIdentity(previous.lastSnapshot)).toBe(accepted);
+ expect(previous.issues.map((issue) => issue.code)).toContain("unknown-result");
+ }
+ expect(api.executeConditionalUpdate).toHaveBeenCalledOnce();
+ });
+
+ it("keeps legacy INVALID records without execution IDs blocked and validates optional durable fields", async () => {
+ isolateRoot();
+ fault = () => "network-before";
+ vi.mocked(api.cancelConditionalUpdate).mockResolvedValue({ requested: false, terminal: false, databaseTerminal: false });
+ const plan = await prepareOracleTypeManagement(target, "save-body", [draft("ROOT", body, "TYPE BODY")]);
+ await expect(executeOracleTypeManagement(plan, { persist: async () => {} })).rejects.toThrow();
+ delete plan.steps[0].executionId;
+ delete plan.steps[0].databaseTerminal;
+ const actual = objects.get(identity("ROOT", "TYPE BODY"))!;
+ actual.status = "INVALID";
+ const legacy = restoreOracleTypeManagementDraft(json(plan))!;
+ vi.mocked(api.cancelConditionalUpdate).mockClear();
+ const rechecked = await prepareOracleTypeManagement(target, "save-body", legacy.drafts, legacy);
+ expect(rechecked.executable).toBe(false);
+ expect(api.cancelConditionalUpdate).not.toHaveBeenCalled();
+ expect(rechecked.steps[0].state).toBe("unknown");
+ expect(restoreOracleTypeManagementDraft({ ...json(plan), steps: [{ ...plan.steps[0], databaseTerminal: true }] })).toBeUndefined();
+ expect(restoreOracleTypeManagementDraft({ ...json(plan), steps: [{ ...plan.steps[0], executionId: 1 }] })).toBeUndefined();
+ });
+
+ it("repairs an INVALID write after its completed execution response was lost without replaying confirmed steps", async () => {
+ fault = (input) => (input.operation === "rebuild_source" && input.objectType === "TYPE_BODY" ? "invalid" : undefined);
+ const execute = vi.mocked(api.executeConditionalUpdate).getMockImplementation()!;
+ vi.mocked(api.executeConditionalUpdate).mockImplementation(async (...args) => {
+ const result = await execute(...args);
+ if (statements.get(args[2])?.objectType === "TYPE_BODY") throw new Error("Lost response after completed INVALID DDL");
+ return result;
+ });
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [draft()]);
+ await expect(executeOracleTypeManagement(plan, { persist: async () => {} })).rejects.toThrow();
+ expect(objects.get(identity("ROOT", "TYPE BODY"))?.status).toBe("INVALID");
+ const sent = requests.length;
+ const restored = restoreOracleTypeManagementDraft(json(plan))!;
+ const reconciled = await prepareOracleTypeManagement(target, "save-spec", restored.drafts, restored);
+ expect(reconciled.issues).toEqual([]);
+ fault = undefined;
+ vi.mocked(api.executeConditionalUpdate).mockImplementation(execute);
+ const fixed = reconciled.drafts.map((item) => (item.objectType === "TYPE BODY" ? { ...item, source: item.source.replace("RETURN SELF.ID", "RETURN SELF.ID + 1") } : item));
+ const remaining = await prepareOracleTypeManagement(target, "save-spec", fixed, reconciled);
+ expect(remaining.issues).toEqual([]);
+ await executeOracleTypeManagement(remaining, { persist: async () => {} });
+ expect(remaining.state).toBe("complete");
+ expect(requests.slice(sent).every((sql) => !sql.startsWith("DROP TYPE") && sql !== changedRoot)).toBe(true);
+ expect(objects.get(identity("ROOT", "TYPE BODY"))?.source).toContain("RETURN SELF.ID + 1");
+ });
+
+ it.each(["reject", "invalid"] as const)("keeps the %s attempt and diagnostic when reopening an unchanged failed draft", async (failure) => {
+ isolateRoot();
+ fault = () => failure;
+ const plan = await prepareOracleTypeManagement(target, "save-body", [draft("ROOT", body.replace("RETURN SELF.ID", "RETURN SELF.ID + 4"), "TYPE BODY")]);
+ await expect(executeOracleTypeManagement(plan, { persist: async () => {} })).rejects.toThrow();
+ const failed = json(plan.steps[0]);
+ expect(failed.state).toBe("failed");
+ expect(failed.message).toBeTruthy();
+ const reopened = await prepareOracleTypeManagement(target, "save-body", plan.drafts, restoreOracleTypeManagementDraft(json(plan)));
+ expect(reopened.history).toEqual([failed]);
+ expect(reopened.steps[0].state).toBe("not-sent");
+ expect(api.executeConditionalUpdate).toHaveBeenCalledOnce();
+ const rechecked = await prepareOracleTypeManagement(target, "save-body", reopened.drafts, restoreOracleTypeManagementDraft(json(reopened)));
+ expect(rechecked.history).toEqual([failed]);
+ expect(api.executeConditionalUpdate).toHaveBeenCalledOnce();
+ fault = () => (failure === "reject" ? "invalid" : "reject");
+ await expect(executeOracleTypeManagement(rechecked, { persist: async () => {} })).rejects.toThrow();
+ const secondFailure = json(rechecked.steps[0]);
+ expect(secondFailure.id).toBe(failed.id);
+ expect(secondFailure.message).not.toBe(failed.message);
+ const retried = await prepareOracleTypeManagement(target, "save-body", rechecked.drafts, restoreOracleTypeManagementDraft(json(rechecked)));
+ expect(retried.history).toEqual([failed, secondFailure]);
+ const validatedAgain = await prepareOracleTypeManagement(target, "save-body", retried.drafts, restoreOracleTypeManagementDraft(json(retried)));
+ expect(validatedAgain.history).toEqual(retried.history);
+ expect(api.executeConditionalUpdate).toHaveBeenCalledTimes(2);
+ });
+
+ it("can revalidate a rejected grant with no effect and resume without dropping rebuilt types again", async () => {
+ fault = (input) => (input.operation === "grant_privilege" ? "reject" : undefined);
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [draft()]);
+ await expect(executeOracleTypeManagement(plan, { persist: async () => {} })).rejects.toThrow();
+ expect(plan.steps.find((step) => step.kind === "grant")?.state).toBe("failed");
+ const writes = requests.length;
+ fault = undefined;
+ const next = await prepareOracleTypeManagement(target, "save-spec", plan.drafts, restoreOracleTypeManagementDraft(json(plan)));
+ expect(next.issues).toEqual([]);
+ await executeOracleTypeManagement(next, { persist: async () => {} });
+ expect(next.state).toBe("complete");
+ expect(requests.slice(writes)[0]).toMatch(/^GRANT/);
+ expect(requests.slice(writes).some((sql) => sql.startsWith("DROP TYPE") || sql === changedRoot)).toBe(false);
+ });
+ it("does not turn a VALID but different post-write definition into a retryable failure", async () => {
+ isolateRoot();
+ const desired = body.replace("RETURN SELF.ID", "RETURN SELF.ID + 5");
+ const concurrent = body.replace("RETURN SELF.ID", "RETURN SELF.ID + 9");
+ const plan = await prepareOracleTypeManagement(target, "save-body", [draft("ROOT", desired, "TYPE BODY")]);
+ const execute = vi.mocked(api.executeConditionalUpdate).getMockImplementation()!;
+ vi.mocked(api.executeConditionalUpdate).mockImplementation(async (...args) => {
+ const result = await execute(...args);
+ const current = objects.get(identity("ROOT", "TYPE BODY"))!;
+ current.source = current.sourceFingerprint = concurrent;
+ return result;
+ });
+ await expect(executeOracleTypeManagement(plan, { persist: async () => {} })).rejects.toThrow("not been verified");
+ expect(plan.steps[0].state).toBe("unknown");
+ const rechecked = await prepareOracleTypeManagement(target, "save-body", plan.drafts, restoreOracleTypeManagementDraft(json(plan)));
+ expect(rechecked.executable).toBe(false);
+ expect(rechecked.issues.map((issue) => issue.code)).toContain("unknown-result");
+ expect(api.executeConditionalUpdate).toHaveBeenCalledOnce();
+ });
+ it("retains a terminal SQL rejection as failed and retries only after fresh validation and confirmation", async () => {
+ isolateRoot();
+ const changedBody = body.replace("RETURN SELF.ID", "RETURN SELF.ID + 8");
+ const plan = await prepareOracleTypeManagement(target, "save-body", [draft("ROOT", changedBody, "TYPE BODY")]);
+ const execute = vi.mocked(api.executeConditionalUpdate).getMockImplementation()!;
+ vi.mocked(api.executeConditionalUpdate).mockRejectedValueOnce(
+ new BackendErrorException({
+ version: 1,
+ code: "DBX-JDBC-4001",
+ messageKey: "backendErrors.jdbc.sqlFailed",
+ messageParams: {},
+ source: "jdbcAgent",
+ origin: { subsystem: "database", adapter: "jdbcAgent" },
+ operationOutcome: "unknown",
+ diagnostics: { category: "sql", stage: "execute" },
+ detail: "Insufficient privileges",
+ }),
+ );
+ await expect(executeOracleTypeManagement(plan, { persist: async () => {} })).rejects.toThrow("Insufficient privileges");
+ expect(plan.steps[0].state).toBe("failed");
+ await expect(executeOracleTypeManagement(plan, { persist: async () => {} })).rejects.toThrow("Revalidate");
+ expect(api.executeConditionalUpdate).toHaveBeenCalledTimes(1);
+ vi.mocked(api.executeConditionalUpdate).mockImplementation(execute);
+ const resumed = await prepareOracleTypeManagement(target, "save-body", plan.drafts, restoreOracleTypeManagementDraft(json(plan)));
+ expect(resumed.executable).toBe(true);
+ await executeOracleTypeManagement(resumed, { persist: async () => {} });
+ expect(resumed.state).toBe("complete");
+ expect(api.executeConditionalUpdate).toHaveBeenCalledTimes(2);
+ });
+
+ it("flushes each exact sent revision before SQL and each readback before the next step", async () => {
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [draft()]);
+ const saved: Array<{ revision: number; sent: number; confirmed: number; dispatched: number }> = [];
+ const persist = async (value: OracleTypeManagementDraft) => {
+ saved.push({ revision: value.revision, sent: value.steps.filter((step) => step.state === "sent").length, confirmed: value.steps.filter((step) => step.state === "confirmed").length, dispatched: requests.length });
+ };
+ await executeOracleTypeManagement(plan, { persist });
+ expect(plan.state).toBe("complete");
+ expect(plan.steps.every((step) => step.state === "confirmed")).toBe(true);
+ expect(saved.filter((entry) => entry.sent).every((entry) => entry.dispatched === entry.confirmed)).toBe(true);
+ expect(objects.get(identity("COLL"))?.directPrivileges[0].grantable).toBe(true);
+ expect(objects.get(identity("ROOT", "TYPE BODY"))?.status).toBe("VALID");
+ });
+
+ it("does not dispatch when durable saving fails or confirmation becomes stale", async () => {
+ isolateRoot();
+ const first = await prepareOracleTypeManagement(target, "save-body", [draft("ROOT", body, "TYPE BODY")]);
+ await expect(
+ executeOracleTypeManagement(first, {
+ persist: async () => {
+ throw new Error("app_state write failed");
+ },
+ }),
+ ).rejects.toBeInstanceOf(OracleTypeManagementFailure);
+ expect(api.executeConditionalUpdate).not.toHaveBeenCalled();
+ expect(first.steps[0].state).toBe("not-sent");
+ const second = await prepareOracleTypeManagement(target, "save-body", [draft("ROOT", body, "TYPE BODY")]);
+ let current = true;
+ await expect(
+ executeOracleTypeManagement(second, {
+ persist: async () => {
+ current = false;
+ },
+ isCurrent: () => current,
+ }),
+ ).rejects.toThrow("changed before dispatch");
+ expect(api.executeConditionalUpdate).not.toHaveBeenCalled();
+ });
+
+ it("binds dispatched steps to the approved target even if the UI switches later", async () => {
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [draft()]);
+ await executeOracleTypeManagement(plan, { persist: async () => {}, isCurrent: () => requests.length === 0 });
+ expect(plan.state).toBe("complete");
+ expect(vi.mocked(api.executeConditionalUpdate).mock.calls.every(([connection, database]) => connection === target.connectionId && database === target.database)).toBe(true);
+ });
+
+ it("detects source/grant/dependency concurrency before sending any DDL", async () => {
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [draft()]);
+ objects.get(identity("FN", "FUNCTION"))!.source += " -- concurrent";
+ await expect(executeOracleTypeManagement(plan, { persist: async () => {} })).rejects.toThrow("changed");
+ expect(api.executeConditionalUpdate).not.toHaveBeenCalled();
+ });
+
+ it("does not call INVALID with zero errors a success; repaired BODY resumes without replaying the root or drops", async () => {
+ fault = (input) => (input.operation === "rebuild_source" && input.objectType === "TYPE_BODY" ? "invalid" : undefined);
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [draft()]);
+ await expect(executeOracleTypeManagement(plan, { persist: async () => {} })).rejects.toThrow("INVALID");
+ expect(plan.state).toBe("stopped");
+ const writes = requests.length;
+ const restored = restoreOracleTypeManagementDraft(json(plan))!;
+ expect(restored.requiresReverify).toBe(true);
+ await expect(executeOracleTypeManagement(restored, { persist: async () => {} })).rejects.toThrow("Revalidate");
+ fault = undefined;
+ const fixed = restored.drafts.map((item) => (item.objectType === "TYPE BODY" ? { ...item, source: item.source.replace("RETURN SELF.ID", "RETURN SELF.ID + 1") } : item));
+ const remaining = await prepareOracleTypeManagement(target, "save-spec", fixed, restored);
+ expect(remaining.issues).toEqual([]);
+ await executeOracleTypeManagement(remaining, { persist: async () => {} });
+ expect(requests.slice(writes).every((sql) => !sql.startsWith("DROP TYPE") && sql !== changedRoot)).toBe(true);
+ expect(remaining.history.some((step) => step.state === "failed" && step.object.objectType === "TYPE BODY")).toBe(true);
+ });
+
+ it("confirms a lost response from actual state and never resends an unresolved unknown write", async () => {
+ isolateRoot();
+ fault = (input) => (input.operation === "save_body" ? "network-after" : undefined);
+ const applied = await prepareOracleTypeManagement(target, "save-body", [draft("ROOT", body, "TYPE BODY")]);
+ await executeOracleTypeManagement(applied, { persist: async () => {} });
+ expect(requests).toHaveLength(1);
+ expect(applied.steps[0].state).toBe("confirmed");
+
+ fault = () => "network-before";
+ const changedBody = body.replace("RETURN SELF.ID", "RETURN SELF.ID + 2");
+ const unknown = await prepareOracleTypeManagement(target, "save-body", [draft("ROOT", changedBody, "TYPE BODY")]);
+ await expect(executeOracleTypeManagement(unknown, { persist: async () => {} })).rejects.toThrow("unknown");
+ expect(unknown.steps[0].state).toBe("unknown");
+ const attempts = requests.length;
+ const rechecked = await prepareOracleTypeManagement(target, "save-body", unknown.drafts, restoreOracleTypeManagementDraft(json(unknown)));
+ expect(rechecked.executable).toBe(false);
+ expect(rechecked.issues.map((issue) => issue.code)).toContain("unknown-result");
+ expect(requests).toHaveLength(attempts);
+ });
+
+ it("does not hide an applied write when readback fails, and stops later sends", async () => {
+ isolateRoot();
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [draft()]);
+ const implementation = vi.mocked(api.executeConditionalUpdate).getMockImplementation()!;
+ vi.mocked(api.executeConditionalUpdate).mockImplementation(async (...args) => {
+ const result = await implementation(...args);
+ vi.mocked(api.getOracleTypeManagementSnapshot).mockRejectedValue(new Error("Readback unavailable"));
+ return result;
+ });
+ await expect(executeOracleTypeManagement(plan, { persist: async () => {} })).rejects.toThrow("Readback unavailable");
+ expect(objects.get(identity("ROOT"))?.source).toBe(changedRoot);
+ expect(plan.steps[0].state).toBe("unknown");
+ expect(requests).toHaveLength(1);
+ });
+
+ it("does not depend on response order, but preserves precise identity, grants and definitions in concurrency checks", () => {
+ const first = snapshot();
+ const reordered = json(first);
+ reordered.target = { owner: first.target.owner, name: first.target.name, database: first.target.database, connectionId: first.target.connectionId };
+ reordered.objects.reverse();
+ reordered.dependencies.reverse();
+ expect(typeManagementSnapshotIdentity(first)).toBe(typeManagementSnapshotIdentity(reordered));
+ reordered.objects[0].source += " -- changed";
+ expect(typeManagementSnapshotIdentity(first)).not.toBe(typeManagementSnapshotIdentity(reordered));
+ expect(restoreOracleTypeManagementDraft({ version: 1, executable: true })).toBeUndefined();
+ });
+});
diff --git a/apps/desktop/src/lib/app/openTabsPersistence.ts b/apps/desktop/src/lib/app/openTabsPersistence.ts
index 8001117d0c..f2790ddcdc 100644
--- a/apps/desktop/src/lib/app/openTabsPersistence.ts
+++ b/apps/desktop/src/lib/app/openTabsPersistence.ts
@@ -1,5 +1,6 @@
import type { QueryResultSourceLabelKind, QueryTab, TabOutputView } from "@/types/database";
import { sanitizeTabUiState } from "@/lib/tabs/tabUiState";
+import { restoreOracleTypeManagementDraft } from "@/lib/table/oracleTypeManagement";
export const OPEN_TABS_STORAGE_KEY = "dbx-open-tabs";
export const ACTIVE_TAB_STORAGE_KEY = "dbx-active-tab";
@@ -73,6 +74,7 @@ export interface SavedOpenTab {
databaseSearchState?: QueryTab["databaseSearchState"];
objectBrowser?: QueryTab["objectBrowser"];
objectSource?: QueryTab["objectSource"];
+ typeManagementDraft?: QueryTab["typeManagementDraft"];
objectDetails?: QueryTab["objectDetails"];
sourceView?: boolean;
ddlViewer?: QueryTab["ddlViewer"];
@@ -109,7 +111,7 @@ export interface OpenTabsStatePayload {
sizes?: number[];
}
-export type OpenTabsRestoreFilter = "all" | "pinned";
+export type OpenTabsRestoreFilter = "all" | "pinned" | "recovery";
export interface OpenTabsRestoreOptions {
queryOnly?: boolean;
filter?: OpenTabsRestoreFilter;
@@ -125,7 +127,7 @@ function shouldPersistTabSql(tab: QueryTab) {
// its request is in flight would restore an empty source tab after restart,
// because the request itself is intentionally not durable.
function shouldPersistOpenTab(tab: QueryTab): boolean {
- return !tab.sourceLoad;
+ return !tab.sourceLoad || !!tab.typeManagementDraft;
}
function restoredOriginalSql(tab: SavedOpenTab, mode: QueryTab["mode"], sql: string) {
@@ -225,6 +227,7 @@ export function serializeOpenTabs(tabs: QueryTab[]): SavedOpenTab[] {
...(tab.databaseSearchState ? { databaseSearchState: tab.databaseSearchState } : {}),
objectBrowser: tab.objectBrowser,
objectSource: tab.objectSource,
+ ...(tab.typeManagementDraft ? { typeManagementDraft: JSON.parse(JSON.stringify(tab.typeManagementDraft)) } : {}),
...(tab.objectDetails ? { objectDetails: { ...tab.objectDetails } } : {}),
...(tab.sourceView ? { sourceView: true } : {}),
...(tab.ddlViewer ? { ddlViewer: { ...tab.ddlViewer } } : {}),
@@ -276,8 +279,11 @@ function restoreOpenTabsArray(parsed: unknown, rawActiveTabId: string | null, op
const saved = parsed.filter(isSavedOpenTab);
const filtered = saved.filter((tab) => {
const mode = tab.mode ?? "query";
+ const recovery = restoreOracleTypeManagementDraft(tab.typeManagementDraft);
+ const unfinishedTypeChange = !!recovery && recovery.state !== "complete";
if (options.queryOnly && mode !== "query") return false;
- if (options.filter === "pinned" && !tab.pinned) return false;
+ if (options.filter === "pinned" && !tab.pinned && !unfinishedTypeChange) return false;
+ if (options.filter === "recovery" && !unfinishedTypeChange) return false;
if (mode !== "query" && validConnectionIds && !validConnectionIds.has(tab.connectionId)) return false;
return true;
});
@@ -303,6 +309,8 @@ function restoreOpenTabsArray(parsed: unknown, rawActiveTabId: string | null, op
// sourceLoad 是纯运行期态(serializeOpenTabs 不落盘)。这里显式清空,
// 让「恢复后的 tab 不会停在加载中」成为不变量,而不是依赖白名单的副作用。
sourceLoad: undefined,
+ typeManagementDraft: mode === "query" ? restoreOracleTypeManagementDraft(tab.typeManagementDraft) : undefined,
+ typeSourceEditing: false,
executingResultRunId: undefined,
editorViewport: restoredEditorViewport(tab),
editorSelection: restoredEditorSelection(tab, typeof tab.sql === "string" ? tab.sql.length : 0),
diff --git a/apps/desktop/src/lib/backend/__tests__/oracleTypeManagementApi.spec.ts b/apps/desktop/src/lib/backend/__tests__/oracleTypeManagementApi.spec.ts
new file mode 100644
index 0000000000..61af3e68cb
--- /dev/null
+++ b/apps/desktop/src/lib/backend/__tests__/oracleTypeManagementApi.spec.ts
@@ -0,0 +1,131 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({ invoke: vi.fn() }));
+vi.mock("@tauri-apps/api/core", () => ({ invoke: mocks.invoke }));
+vi.mock("@tauri-apps/api/event", () => ({ listen: vi.fn() }));
+
+const target = { connectionId: "connection 1", database: "Db/Exact", owner: "MiXeD O'wner", name: "Edit' Type (v1)" };
+const knownObjects = [{ owner: target.owner, name: "Removed Dependency", objectType: "TYPE" }];
+const payload = {
+ target,
+ visibilityScope: "current-user-visible-dictionaries",
+ details: null,
+ detailsRead: { state: "unavailable", reason: "No permission" },
+ dependencies: [],
+ dependenciesRead: { state: "incomplete", reason: "Result was truncated" },
+ objects: [{ owner: target.owner, name: "Removed Dependency", objectType: "TYPE", exists: false, objectId: null, status: null }],
+};
+
+beforeEach(() => vi.clearAllMocks());
+afterEach(() => vi.unstubAllGlobals());
+
+describe("Oracle-family TYPE management transports", () => {
+ it.each([undefined, { cancel: false }, { cancel: false, typeRecovery: { executionId: "type-step-1", planId: "plan", stepId: "step", connectionId: target.connectionId, database: target.database, schema: target.owner, sql: "approved SQL" } }])(
+ "preserves cancellation defaults and forwards TYPE wait-only options over both transports: %j",
+ async (options) => {
+ const response = { requested: false, terminal: true, databaseTerminal: true };
+ const fetchMock = vi.fn().mockResolvedValue({ ok: true, status: 200, json: async () => response });
+ vi.stubGlobal("fetch", fetchMock);
+ mocks.invoke.mockResolvedValue(response);
+ const http = await import("@/lib/backend/http");
+ const tauri = await import("@/lib/backend/tauri");
+ await expect(http.cancelConditionalUpdate("type-step-1", options)).resolves.toEqual(response);
+ await expect(tauri.cancelConditionalUpdate("type-step-1", options)).resolves.toEqual(response);
+ expect(fetchMock).toHaveBeenCalledWith("/api/query/cancel-conditional-update", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ executionId: "type-step-1", ...options }) });
+ expect(mocks.invoke).toHaveBeenCalledWith("cancel_conditional_update", { executionId: "type-step-1", ...options });
+ },
+ );
+
+ it.each([undefined, { typeRecovery: { planId: "plan", stepId: "step" } }])("forwards opt-in TYPE execution context without changing ordinary calls: %j", async (options) => {
+ const response = { columns: [], rows: [], affected_rows: 0 };
+ const fetchMock = vi.fn().mockResolvedValue({ ok: true, status: 200, json: async () => response });
+ vi.stubGlobal("fetch", fetchMock);
+ mocks.invoke.mockResolvedValue(response);
+ const http = await import("@/lib/backend/http");
+ const tauri = await import("@/lib/backend/tauri");
+ await expect(http.executeConditionalUpdate(target.connectionId, target.database, "approved SQL", target.owner, "type-step-1", options)).resolves.toEqual(response);
+ await expect(tauri.executeConditionalUpdate(target.connectionId, target.database, "approved SQL", target.owner, "type-step-1", options)).resolves.toEqual(response);
+ const input = { connectionId: target.connectionId, database: target.database, sql: "approved SQL", schema: target.owner, executionId: "type-step-1", ...options };
+ expect(fetchMock).toHaveBeenCalledWith("/api/query/execute-conditional-update", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(input) });
+ expect(mocks.invoke).toHaveBeenCalledWith("execute_conditional_update", input);
+ });
+
+ it("uses the same read-only native evolution preview and recovery manifest over both transports", async () => {
+ const response = { target, sourceBefore: "original definition", sourceAfter: "approved definition", statements: ["native preview"], metadata: "unchanged targets", phase: 1 };
+ const input = { target, sourceBefore: response.sourceBefore, sourceAfter: response.sourceAfter, manifest: response };
+ const fetchMock = vi.fn().mockResolvedValue({ ok: true, status: 200, json: async () => response });
+ vi.stubGlobal("fetch", fetchMock);
+ mocks.invoke.mockResolvedValue(response);
+ const http = await import("@/lib/backend/http");
+ const tauri = await import("@/lib/backend/tauri");
+ await expect(http.prepareOracleTypeEvolution(input)).resolves.toEqual(response);
+ await expect(tauri.prepareOracleTypeEvolution(input)).resolves.toEqual(response);
+ expect(fetchMock).toHaveBeenCalledWith("/api/schema/oracle-type-evolution", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(input) });
+ expect(mocks.invoke).toHaveBeenCalledWith("prepare_oracle_type_evolution", { input });
+ });
+ it.each(["describe", "register", "verify", "validate_insert"] as const)("uses the same bounded data %s contract over both transports", async (action) => {
+ const response = { relation: null, manifest: null, insertSql: null };
+ const fetchMock = vi.fn().mockResolvedValue({ ok: true, status: 200, json: async () => response });
+ vi.stubGlobal("fetch", fetchMock);
+ mocks.invoke.mockResolvedValue(response);
+ const input = { target, action, relation: { owner: target.owner, name: "Permanent' Table" }, sql: "fixture draft" };
+ const http = await import("@/lib/backend/http");
+ const tauri = await import("@/lib/backend/tauri");
+ await expect(http.verifyOracleTypeData(input)).resolves.toEqual(response);
+ await expect(tauri.verifyOracleTypeData(input)).resolves.toEqual(response);
+ expect(fetchMock).toHaveBeenCalledWith("/api/schema/oracle-type-data", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(input) });
+ expect(mocks.invoke).toHaveBeenCalledWith("verify_oracle_type_data", { input });
+ });
+ it("preserves exact names and independent failed sections over HTTP GET", async () => {
+ const fetchMock = vi.fn().mockResolvedValue({ ok: true, status: 200, json: async () => payload });
+ vi.stubGlobal("fetch", fetchMock);
+ const http = await import("@/lib/backend/http");
+ await expect(http.getOracleTypeManagementSnapshot(target.connectionId, target.database, target.owner, target.name)).resolves.toEqual(payload);
+ const url = new URL(fetchMock.mock.calls[0][0], "http://fixture");
+ expect(url.pathname).toBe("/api/schema/oracle-type-management-snapshot");
+ expect(Object.fromEntries(url.searchParams)).toEqual({ connection_id: target.connectionId, database: target.database, schema: target.owner, table: target.name });
+ });
+
+ it("posts known identities so recovery can inspect objects after their edges disappear", async () => {
+ const fetchMock = vi.fn().mockResolvedValue({ ok: true, status: 200, json: async () => payload });
+ vi.stubGlobal("fetch", fetchMock);
+ const http = await import("@/lib/backend/http");
+ await expect(http.getOracleTypeManagementSnapshot(target.connectionId, target.database, target.owner, target.name, knownObjects)).resolves.toEqual(payload);
+ expect(fetchMock).toHaveBeenCalledWith("/api/schema/oracle-type-management-snapshot", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({ target, knownObjects }),
+ });
+ });
+
+ it("passes the same recovery identity and read state through Tauri", async () => {
+ mocks.invoke.mockResolvedValue(payload);
+ const tauri = await import("@/lib/backend/tauri");
+ await expect(tauri.getOracleTypeManagementSnapshot(target.connectionId, target.database, target.owner, target.name, knownObjects)).resolves.toEqual(payload);
+ expect(mocks.invoke).toHaveBeenCalledWith("get_oracle_type_management_snapshot", { ...target, knownObjects });
+ });
+
+ it("does not turn a failed snapshot request into an empty successful snapshot", async () => {
+ vi.stubGlobal("fetch", vi.fn().mockRejectedValue(new Error("Offline")));
+ const http = await import("@/lib/backend/http");
+ await expect(http.getOracleTypeManagementSnapshot(target.connectionId, target.database, target.owner, target.name)).rejects.toThrow("Offline");
+ });
+
+ it.each(["save_spec", "save_body", "drop_spec", "drop_body", "grant_execute", "grant_privilege", "rebuild_source", "compile_spec"] as const)("previews %s through the SQL builder rather than the execution route", async (operation) => {
+ const response = { statements: ["fixture preview"] };
+ const fetchMock = vi.fn().mockResolvedValue({ ok: true, status: 200, json: async () => response });
+ vi.stubGlobal("fetch", fetchMock);
+ mocks.invoke.mockResolvedValue(response);
+ const http = await import("@/lib/backend/http");
+ const tauri = await import("@/lib/backend/tauri");
+ const input = { databaseType: "oceanbase-oracle" as const, operation, owner: target.owner, name: target.name, source: "fixture source", grantable: true, objectType: "FUNCTION" as const, privilege: "DEBUG" };
+ await expect(http.buildOracleTypeManagementSql(input)).resolves.toEqual(response);
+ await expect(tauri.buildOracleTypeManagementSql(input)).resolves.toEqual(response);
+ expect(fetchMock).toHaveBeenCalledWith("/api/query/build-oracle-type-management-sql", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify(input),
+ });
+ expect(mocks.invoke).toHaveBeenCalledWith("build_oracle_type_management_sql", { input });
+ });
+});
diff --git a/apps/desktop/src/lib/backend/api.ts b/apps/desktop/src/lib/backend/api.ts
index 3f5f6d0a57..0f6f128adc 100644
--- a/apps/desktop/src/lib/backend/api.ts
+++ b/apps/desktop/src/lib/backend/api.ts
@@ -227,6 +227,10 @@ export const completionAssistantSearch = forward("completionAssistantSearch");
export const getObjectSource = forward("getObjectSource");
export const getEventInfo = forward("getEventInfo");
export const getCustomTypeDetails = forward("getCustomTypeDetails");
+export const getOracleTypeManagementSnapshot = forward("getOracleTypeManagementSnapshot");
+export const buildOracleTypeManagementSql = forward("buildOracleTypeManagementSql");
+export const verifyOracleTypeData = forward("verifyOracleTypeData");
+export const prepareOracleTypeEvolution = forward("prepareOracleTypeEvolution");
export const getColumns = forward("getColumns");
export const getPluginTableMetadata = forward("getPluginTableMetadata");
export const getAllColumns = forward("getAllColumns");
diff --git a/apps/desktop/src/lib/backend/http.ts b/apps/desktop/src/lib/backend/http.ts
index e8a722de30..d7ed4df649 100644
--- a/apps/desktop/src/lib/backend/http.ts
+++ b/apps/desktop/src/lib/backend/http.ts
@@ -48,6 +48,14 @@ import type {
CompletionAssistantResponse,
ObjectStatistics,
CustomTypeDetails,
+ OracleTypeManagementSnapshot,
+ OracleTypeManagementObjectKey,
+ OracleTypeManagementSqlInput,
+ OracleTypeManagementSqlResult,
+ OracleTypeDataRequest,
+ OracleTypeDataResult,
+ OracleTypeEvolutionRequest,
+ OracleTypeEvolutionManifest,
ObjectSource,
ObjectSourceKind,
MysqlEventInfo,
@@ -1297,6 +1305,20 @@ export async function getCustomTypeDetails(connectionId: string, database: strin
return get(`/api/schema/custom-type-details?${qs({ connection_id: connectionId, database, schema, table: name })}`);
}
+export async function getOracleTypeManagementSnapshot(connectionId: string, database: string, owner: string, name: string, knownObjects: OracleTypeManagementObjectKey[] = []): Promise<OracleTypeManagementSnapshot> {
+ if (knownObjects.length) return post("/api/schema/oracle-type-management-snapshot", { target: { connectionId, database, owner, name }, knownObjects });
+ return get(`/api/schema/oracle-type-management-snapshot?${qs({ connection_id: connectionId, database, schema: owner, table: name })}`);
+}
+export function buildOracleTypeManagementSql(input: OracleTypeManagementSqlInput): Promise<OracleTypeManagementSqlResult> {
+ return post("/api/query/build-oracle-type-management-sql", input);
+}
+export function verifyOracleTypeData(input: OracleTypeDataRequest): Promise<OracleTypeDataResult> {
+ return post("/api/schema/oracle-type-data", input);
+}
+export function prepareOracleTypeEvolution(input: OracleTypeEvolutionRequest): Promise<OracleTypeEvolutionManifest> {
+ return post("/api/schema/oracle-type-evolution", input);
+}
+
export async function getColumns(connectionId: string, database: string, schema: string, table: string, catalog?: string, clientSessionId?: string, currentSchema?: string, exactIdentity?: boolean): Promise<ColumnInfo[]> {
return get(`/api/schema/columns?${qs({ connection_id: connectionId, database, schema, table, catalog, client_session_id: clientSessionId, current_schema: currentSchema, exact_identity: exactIdentity || undefined })}`);
}
@@ -1562,6 +1584,7 @@ export async function executeConditionalUpdate(
clientSessionId?: string;
timeoutSecs?: number;
executionMode?: "simple" | "postgres_read_only_transaction";
+ typeRecovery?: import("@/types/database").TypeRecoveryContext;
},
): Promise<QueryResult> {
return post("/api/query/execute-conditional-update", {
@@ -1839,10 +1862,11 @@ export async function cancelQuery(executionId: string): Promise<boolean> {
export interface ConditionalUpdateCancellationResult {
requested: boolean;
terminal: boolean;
+ databaseTerminal?: boolean;
}
-export async function cancelConditionalUpdate(executionId: string): Promise<ConditionalUpdateCancellationResult> {
- return post("/api/query/cancel-conditional-update", { executionId });
+export async function cancelConditionalUpdate(executionId: string, options?: { cancel?: boolean; typeRecovery?: import("@/types/database").TypeExecutionBinding }): Promise<ConditionalUpdateCancellationResult> {
+ return post("/api/query/cancel-conditional-update", { executionId, ...options });
}
export async function analyzeSqlReferences(sql: string, dialect?: string): Promise<SqlReferenceAnalysis> {
diff --git a/apps/desktop/src/lib/backend/tauri.ts b/apps/desktop/src/lib/backend/tauri.ts
index b1a9a1fa9c..4c328ee036 100644
--- a/apps/desktop/src/lib/backend/tauri.ts
+++ b/apps/desktop/src/lib/backend/tauri.ts
@@ -82,6 +82,14 @@ import type {
CompletionAssistantResponse,
ObjectStatistics,
CustomTypeDetails,
+ OracleTypeManagementSnapshot,
+ OracleTypeManagementObjectKey,
+ OracleTypeManagementSqlInput,
+ OracleTypeManagementSqlResult,
+ OracleTypeDataRequest,
+ OracleTypeDataResult,
+ OracleTypeEvolutionRequest,
+ OracleTypeEvolutionManifest,
ObjectSource,
ObjectSourceKind,
MysqlEventInfo,
@@ -1911,6 +1919,18 @@ export async function listSchemaInfos(connectionId: string, database: string): P
export async function getCustomTypeDetails(connectionId: string, database: string, schema: string, name: string): Promise<CustomTypeDetails> {
return invoke("get_custom_type_details", { connectionId, database, schema, name });
}
+export async function getOracleTypeManagementSnapshot(connectionId: string, database: string, owner: string, name: string, knownObjects: OracleTypeManagementObjectKey[] = []): Promise<OracleTypeManagementSnapshot> {
+ return invoke("get_oracle_type_management_snapshot", { connectionId, database, owner, name, knownObjects });
+}
+export function buildOracleTypeManagementSql(input: OracleTypeManagementSqlInput): Promise<OracleTypeManagementSqlResult> {
+ return invoke("build_oracle_type_management_sql", { input });
+}
+export function verifyOracleTypeData(input: OracleTypeDataRequest): Promise<OracleTypeDataResult> {
+ return invoke("verify_oracle_type_data", { input });
+}
+export function prepareOracleTypeEvolution(input: OracleTypeEvolutionRequest): Promise<OracleTypeEvolutionManifest> {
+ return invoke("prepare_oracle_type_evolution", { input });
+}
export async function getColumns(connectionId: string, database: string, schema: string, table: string, catalog?: string, clientSessionId?: string, currentSchema?: string, exactIdentity?: boolean): Promise<ColumnInfo[]> {
return invoke("get_columns", {
connectionId,
@@ -1999,6 +2019,7 @@ export async function executeConditionalUpdate(
clientSessionId?: string;
timeoutSecs?: number;
executionMode?: "simple" | "postgres_read_only_transaction";
+ typeRecovery?: import("@/types/database").TypeRecoveryContext;
},
): Promise<QueryResult> {
try {
@@ -2145,10 +2166,11 @@ export async function cancelQuery(executionId: string): Promise<boolean> {
export interface ConditionalUpdateCancellationResult {
requested: boolean;
terminal: boolean;
+ databaseTerminal?: boolean;
}
-export async function cancelConditionalUpdate(executionId: string): Promise<ConditionalUpdateCancellationResult> {
- return invoke("cancel_conditional_update", { executionId });
+export async function cancelConditionalUpdate(executionId: string, options?: { cancel?: boolean; typeRecovery?: import("@/types/database").TypeExecutionBinding }): Promise<ConditionalUpdateCancellationResult> {
+ return invoke("cancel_conditional_update", { executionId, ...options });
}
export async function readLargeValueChunk(request: import("./http").LargeValueRequest): Promise<import("./http").LargeValueChunk> {
diff --git a/apps/desktop/src/lib/database/databaseObjectCapabilities.ts b/apps/desktop/src/lib/database/databaseObjectCapabilities.ts
index 4f76bc11c3..17407af8a3 100644
--- a/apps/desktop/src/lib/database/databaseObjectCapabilities.ts
+++ b/apps/desktop/src/lib/database/databaseObjectCapabilities.ts
@@ -33,9 +33,9 @@ const KINGBASE_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "MATERIALIZED_VI
const VASTBASE_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "SEQUENCE", "TYPE"];
const POSTGRES_LIKE_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION"];
-const ORACLE_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "SEQUENCE", "INDEX", "SYNONYM", "PACKAGE", "PACKAGE_BODY"];
-const OCEANBASE_ORACLE_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "SEQUENCE", "INDEX", "SYNONYM", "PACKAGE", "PACKAGE_BODY"];
-const DAMENG_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "SEQUENCE", "INDEX", "PACKAGE", "PACKAGE_BODY"];
+const ORACLE_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "SEQUENCE", "INDEX", "SYNONYM", "PACKAGE", "PACKAGE_BODY", "TYPE", "TYPE_BODY"];
+const OCEANBASE_ORACLE_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "SEQUENCE", "INDEX", "SYNONYM", "PACKAGE", "PACKAGE_BODY", "TYPE", "TYPE_BODY"];
+const DAMENG_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "SEQUENCE", "INDEX", "PACKAGE", "PACKAGE_BODY", "TYPE", "TYPE_BODY"];
export function supportsSchemaIndexManagement(dbType?: DatabaseType): boolean {
return dbType === "oracle" || dbType === "oceanbase-oracle" || dbType === "dameng";
@@ -120,8 +120,8 @@ const DATABASE_TYPE_OBJECTS = new Map<DatabaseType, SidebarObjectKind[]>([
]);
/**
* Whether a kind is readable as object source for the given connection type.
- * TYPE/TYPE_BODY only have a real source implementation on Xugu; PostgreSQL-
- * family databases list types without a CREATE TYPE getter this cycle.
+ * TYPE/TYPE_BODY have source getters on Oracle-family databases and Xugu;
+ * PostgreSQL-family databases list types without a CREATE TYPE getter.
*/
function isSourceReadableObjectKind(kind: SidebarObjectKind, dbType?: DatabaseType): boolean {
if (kind === "TABLE" || kind === "INDEX") return false;
@@ -205,7 +205,15 @@ export function sidebarObjectKindsForDatabase(dbType?: DatabaseType, compatibili
* before dispatching getObjectSource.
*/
export function supportsTypeObjectSource(dbType?: DatabaseType): boolean {
- return dbType === "xugu";
+ return dbType === "oracle" || dbType === "oceanbase-oracle" || dbType === "dameng" || dbType === "xugu";
+}
+
+export function supportsOracleFamilyTypeManagement(dbType?: DatabaseType): boolean {
+ return dbType === "oracle" || dbType === "oceanbase-oracle" || dbType === "dameng";
+}
+
+export function isOracleFamilyTypeSource(dbType: DatabaseType | undefined, objectType: string | undefined): boolean {
+ return supportsOracleFamilyTypeManagement(dbType) && (objectType === "TYPE" || objectType === "TYPE_BODY");
}
export type CustomTypeCapabilities = {
@@ -214,7 +222,9 @@ export type CustomTypeCapabilities = {
ddl: boolean;
};
-const VERIFIED_CUSTOM_TYPE_DATABASES = new Set<DatabaseType>(["postgres", "opengauss", "gaussdb", "kingbase", "vastbase"]);
+const VERIFIED_CUSTOM_TYPE_DATABASES = new Set<DatabaseType>(["postgres", "opengauss", "gaussdb", "kingbase", "vastbase", "oracle", "oceanbase-oracle", "dameng"]);
+const ORACLE_TYPE_ATTRIBUTE_DATABASES = new Set<DatabaseType>(["oracle", "oceanbase-oracle", "dameng"]);
+const CUSTOM_TYPE_DDL_DATABASES = new Set<DatabaseType>(["postgres", "opengauss", "gaussdb", "kingbase", "vastbase"]);
/**
* Whether a connection may open read-only custom type details (phase 2).
@@ -223,7 +233,12 @@ const VERIFIED_CUSTOM_TYPE_DATABASES = new Set<DatabaseType>(["postgres", "openg
*/
export function customTypeCapabilities(dbType?: DatabaseType): CustomTypeCapabilities {
const supported = !!dbType && VERIFIED_CUSTOM_TYPE_DATABASES.has(dbType);
- return { details: supported, members: supported, ddl: supported };
+ const hasDdl = !!dbType && CUSTOM_TYPE_DDL_DATABASES.has(dbType);
+ return { details: supported, members: supported, ddl: hasDdl };
+}
+
+export function supportsOracleTypeAttributeExpansion(dbType?: DatabaseType): boolean {
+ return !!dbType && ORACLE_TYPE_ATTRIBUTE_DATABASES.has(dbType);
}
export function supportsPackageMemberExpansion(dbType?: DatabaseType, compatibilityMode?: string): boolean {
diff --git a/apps/desktop/src/lib/settings/__tests__/settingsSearch.spec.ts b/apps/desktop/src/lib/settings/__tests__/settingsSearch.spec.ts
index 60e4c2f8ad..4c6e4e3df2 100644
--- a/apps/desktop/src/lib/settings/__tests__/settingsSearch.spec.ts
+++ b/apps/desktop/src/lib/settings/__tests__/settingsSearch.spec.ts
@@ -40,6 +40,15 @@ const translate = (key: string) => translations[key] ?? key;
const allCategories = new Set(Object.keys(categoryLabels) as SettingsCategory[]);
describe("settings search", () => {
+ it.each([
+ ["connection.httpTunnelProtocol", "Tunnel wire protocol", "wire protocol"],
+ ["connection.httpTunnelProtocolDbx", "DBX tunnel protocol", "dbx tunnel"],
+ ["connection.httpTunnelProtocolNavicat", "Navicat tunnel protocol", "navicat tunnel"],
+ ])("finds %s under the existing tunnel management entry", (translationKey, label, query) => {
+ const entries = resolveSettingsSearchEntries(SETTINGS_SEARCH_DEFINITIONS, { isWeb: true, visibleCategories: new Set<SettingsCategory>(["tunnels"]) }, (key) => (key === translationKey ? label : key), categoryLabels);
+ expect(searchSettings(entries, query, "en")).toEqual(expect.arrayContaining([expect.objectContaining({ id: "tunnels", category: "tunnels", targetId: "tunnels" })]));
+ });
+
it("finds connection tab colors by their Chinese label", () => {
const entries = resolveSettingsSearchEntries(SETTINGS_SEARCH_DEFINITIONS, { isWeb: false, visibleCategories: allCategories }, (key) => (key === "settings.colorizeConnectionTabs" ? "按连接颜色区分标签页" : key), categoryLabels);
expect(searchSettings(entries, "连接颜色", "zh-CN")).toEqual(expect.arrayContaining([expect.objectContaining({ id: "appearance-connection-tab-colors", category: "appearance", targetId: "appearance" })]));
diff --git a/apps/desktop/src/lib/settings/__tests__/settingsSearchCoverage.spec.ts b/apps/desktop/src/lib/settings/__tests__/settingsSearchCoverage.spec.ts
index 862aa1a9a3..5a1ba11fe2 100644
--- a/apps/desktop/src/lib/settings/__tests__/settingsSearchCoverage.spec.ts
+++ b/apps/desktop/src/lib/settings/__tests__/settingsSearchCoverage.spec.ts
@@ -141,7 +141,7 @@ function inspectSettingsTemplates(entry: string): Map<string, Set<string>> {
if (excludedComponents[component]) continue;
const importPath = imports.get(component)!;
const target = importPath.startsWith("@/") ? resolve(src, importPath.slice(2)) : resolve(dirname(file), importPath);
- if (/\/components\/(ui|icons)\//.test(target)) continue;
+ if (/\/components\/(ui|icons)\//.test(target.replaceAll("\\", "/"))) continue;
visit(target);
}
}
diff --git a/apps/desktop/src/lib/sidebar/customTypeTree.ts b/apps/desktop/src/lib/sidebar/customTypeTree.ts
index a9fe2e30f6..11c694711a 100644
--- a/apps/desktop/src/lib/sidebar/customTypeTree.ts
+++ b/apps/desktop/src/lib/sidebar/customTypeTree.ts
@@ -19,6 +19,19 @@ function typeMemberNode(parent: TreeNode, identity: string, label: string, meta:
}
export function buildCustomTypeTreeChildren(parent: TreeNode, details: CustomTypeDetails): TreeNode[] {
+ if (details.oracleMetadata) {
+ if (details.oracleMetadata.attributesRead.state === "unavailable" || details.oracleMetadata.attributesRead.state === "unsupported") return [];
+ return details.oracleMetadata.attributes.map((attribute, index) => {
+ const typeName = [attribute.typeOwner, attribute.typeName, attribute.typeModifier].filter(Boolean).join(".");
+ const typeArguments = attribute.precision != null ? `(${attribute.precision}${attribute.scale == null ? "" : `, ${attribute.scale}`})` : attribute.length != null ? `(${attribute.length})` : "";
+ return typeMemberNode(parent, attribute.name, attribute.name, {
+ kind: "field",
+ displayValue: `${typeName || "—"}${typeArguments}`,
+ ordinal: attribute.ordinal ?? index + 1,
+ });
+ });
+ }
+
if (details.kind === "composite") {
return details.members.map((member) =>
typeMemberNode(parent, member.name, member.name, {
diff --git a/apps/desktop/src/lib/sidebar/sidebarTreeArrowNavigation.ts b/apps/desktop/src/lib/sidebar/sidebarTreeArrowNavigation.ts
index 86af513839..f3db25814f 100644
--- a/apps/desktop/src/lib/sidebar/sidebarTreeArrowNavigation.ts
+++ b/apps/desktop/src/lib/sidebar/sidebarTreeArrowNavigation.ts
@@ -1,7 +1,7 @@
import type { FlatTreeNode } from "@/composables/useFlatTree";
import type { DatabaseType, TreeNode } from "@/types/database";
import { canTreeNodeShowExpander } from "@/lib/sidebar/sidebarTreeItemLayout";
-import { customTypeCapabilities } from "@/lib/database/databaseObjectCapabilities";
+import { customTypeCapabilities, supportsOracleTypeAttributeExpansion } from "@/lib/database/databaseObjectCapabilities";
export type SidebarTreeArrowAction = { kind: "select"; nodeId: string } | { kind: "toggle"; nodeId: string; expanded: boolean } | { kind: "none" };
@@ -47,7 +47,7 @@ function isArrowExpandable(node: TreeNode, databaseType?: DatabaseType): boolean
// PostgreSQL-family custom types only expand when the catalog marked them
// with loadable members; member-less kinds (enum/domain/range/base) stay
// collapsed even when child metadata rows exist.
- if (node.type === "type" && customTypeCapabilities(databaseType).details) return node.hasMembers === true;
+ if (node.type === "type" && customTypeCapabilities(databaseType).details) return node.hasMembers === true || (node.hasMembers === undefined && supportsOracleTypeAttributeExpansion(databaseType));
return canTreeNodeShowExpander({
type: node.type,
childCount: node.children?.length ?? 0,
diff --git a/apps/desktop/src/lib/sidebar/sidebarTreeLabel.ts b/apps/desktop/src/lib/sidebar/sidebarTreeLabel.ts
index b7aa1765e9..7b30eb0e22 100644
--- a/apps/desktop/src/lib/sidebar/sidebarTreeLabel.ts
+++ b/apps/desktop/src/lib/sidebar/sidebarTreeLabel.ts
@@ -2,6 +2,7 @@ import type { TreeNode, DatabaseType, CustomTypeTreeMemberMeta } from "@/types/d
import { isTreeGroupNodeType } from "@/lib/sidebar/treeNodeGroup";
import { xuguSchemaDisplayName } from "@/lib/sidebar/xuguPublicSynonyms";
import { elasticsearchIndexAliasLabel } from "@/lib/sidebar/elasticsearchIndexActions";
+import { supportsOracleTypeAttributeExpansion } from "@/lib/database/databaseObjectCapabilities";
export type SidebarTreeTranslate = (key: string, values?: Record<string, number>) => string;
export function sidebarTreeDisplayLabel(node: TreeNode, t: SidebarTreeTranslate, databaseType?: DatabaseType): string {
@@ -24,8 +25,11 @@ export function sidebarTreeDisplayLabel(node: TreeNode, t: SidebarTreeTranslate,
return isTreeGroupNodeType(node.type) ? t(node.label) : node.label;
}
-export function sidebarTreeSecondaryValue(node: TreeNode, t: SidebarTreeTranslate): string | undefined {
- if (node.type === "type" && node.customTypeKind) return t(`customType.kinds.${node.customTypeKind}`);
+export function sidebarTreeSecondaryValue(node: TreeNode, t: SidebarTreeTranslate, databaseType?: DatabaseType): string | undefined {
+ if (node.type === "type" && node.customTypeKind) {
+ const kindKey = supportsOracleTypeAttributeExpansion(databaseType) ? `oracleType.kinds.${node.customTypeKind in { object: true, collection: true } ? node.customTypeKind : "other"}` : `customType.kinds.${node.customTypeKind}`;
+ return t(kindKey);
+ }
if (node.type === "type-member") return (node.meta as CustomTypeTreeMemberMeta | undefined)?.displayValue;
if (node.type === "datafile") return node.xuguDatafilePath;
if (node.type === "elasticsearch-index") return elasticsearchIndexAliasLabel(node);
diff --git a/apps/desktop/src/lib/sidebar/treeNodeClick.ts b/apps/desktop/src/lib/sidebar/treeNodeClick.ts
index 6a5f22badf..6eda8e7564 100644
--- a/apps/desktop/src/lib/sidebar/treeNodeClick.ts
+++ b/apps/desktop/src/lib/sidebar/treeNodeClick.ts
@@ -154,7 +154,8 @@ export function isDocumentBrowserTreeNode(type: TreeNodeType): boolean {
/**
* Whether a tree node type may open an object source dialog for the given
* connection type. TYPE/TYPE_BODY only have a real source implementation on
- * Xugu; other databases list types without a DDL getter this cycle.
+ * Oracle-family databases and Xugu; PostgreSQL-family databases list types
+ * without a CREATE TYPE getter this cycle.
*/
function canOpenTreeNodeSource(type: TreeNodeType, dbType?: DatabaseType): boolean {
if (type === "type" || type === "type-body") return supportsTypeObjectSource(dbType);
@@ -172,7 +173,7 @@ export function treeNodeRowAction(type: TreeNodeType, canExpand: boolean, activa
if (dataNodeTypes.has(type)) return "open-data";
if (type === "column") return "locate-column";
// PostgreSQL-family custom types: open read-only details (toggle when expandable).
- if (type === "type" && customTypeCapabilities(dbType).details) return canExpand ? "toggle" : "none";
+ if (type === "type" && customTypeCapabilities(dbType).details) return canExpand ? "toggle" : supportsTypeObjectSource(dbType) ? "open-source" : "none";
// Xugu and other databases: expandable package/type nodes toggle their members.
if ((type === "package" || type === "type") && canExpand) return "toggle";
if (sourceNodeTypes.has(type) && canOpenTreeNodeSource(type, dbType)) return "open-source";
@@ -208,7 +209,7 @@ export function treeNodeRowDoubleClickAction(type: TreeNodeType, canOpenObjectBr
if (type === "extension") return "open-extension-details";
if (type === "event-trigger") return "open-event-trigger-details";
if (dataNodeTypes.has(type)) return "open-data";
- if (type === "type" && customTypeCapabilities(dbType).details) return canExpand ? "toggle" : "none";
+ if (type === "type" && customTypeCapabilities(dbType).details) return canExpand ? "toggle" : supportsTypeObjectSource(dbType) ? "open-source" : "none";
if (sourceNodeTypes.has(type) && canOpenTreeNodeSource(type, dbType)) return "open-source";
if (savedSqlNodeTypes.has(type)) return "open-saved-sql";
if (toggleLeafNodeTypes.has(type)) return "toggle";
diff --git a/apps/desktop/src/lib/table/objectBrowserRowAction.ts b/apps/desktop/src/lib/table/objectBrowserRowAction.ts
index a9fecbaad4..04b84122de 100644
--- a/apps/desktop/src/lib/table/objectBrowserRowAction.ts
+++ b/apps/desktop/src/lib/table/objectBrowserRowAction.ts
@@ -13,7 +13,7 @@ export type ObjectBrowserRowAction = "table-info" | "index-info" | "index-editor
* - otherwise → none
*
* TYPE/TYPE_BODY only open source for connections with a real type source
- * implementation (Xugu); other databases list types without a DDL getter.
+ * implementation (Oracle family or Xugu); other databases list types without a DDL getter.
*/
export function singleClickRowAction(row: ObjectBrowserRow | null | undefined, dbType?: DatabaseType): ObjectBrowserRowAction {
if (!row) return "none";
@@ -102,8 +102,8 @@ function mongoObjectBrowserRowAction(row: ObjectBrowserRow): ObjectBrowserRowAct
}
function canOpenSource(row: ObjectBrowserRow, dbType?: DatabaseType): boolean {
- // Verified PG-family TYPE rows open the read-only details panel instead;
- // Xugu keeps its source editor entry through supportsTypeObjectSource below.
+ // Verified custom types open the read-only details panel instead; Oracle
+ // family types and Xugu also use the source entry below.
if (row.type === "TYPE" && customTypeCapabilities(dbType).details) return false;
if ((row.type === "TYPE" || row.type === "TYPE_BODY") && !supportsTypeObjectSource(dbType)) return false;
return (
diff --git a/apps/desktop/src/lib/table/objectSourceTabSave.ts b/apps/desktop/src/lib/table/objectSourceTabSave.ts
index 17edafbc2c..a07921d917 100644
--- a/apps/desktop/src/lib/table/objectSourceTabSave.ts
+++ b/apps/desktop/src/lib/table/objectSourceTabSave.ts
@@ -1,9 +1,11 @@
import type { ConnectionConfig, QueryTab } from "@/types/database";
import type { useQueryStore } from "@/stores/queryStore";
import { effectiveDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
+import { isOracleFamilyTypeSource } from "@/lib/database/databaseObjectCapabilities";
import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
import { assertSourceIdentity, beginSourceSave } from "@/lib/table/objectSourceIdentity";
import { buildExecutableObjectSourceStatements, objectSourceSaveSuccessMessage, prepareObjectSourceSave } from "@/lib/table/objectSourceEditor";
+import { requestOracleTypeManagement } from "@/lib/table/oracleTypeManagementRequest";
interface ObjectSourceTabSaveContext {
connection?: ConnectionConfig;
@@ -19,12 +21,28 @@ export async function saveObjectSourceTab(tab: QueryTab, { connection, queryStor
let save: Awaited<ReturnType<typeof prepareObjectSourceSave>> | undefined;
try {
+ const databaseType = effectiveDatabaseTypeForConnection(connection) ?? connection.db_type;
+ if (isOracleFamilyTypeSource(databaseType, source.objectType)) {
+ if (!tab.typeSourceEditing && (!tab.typeManagementDraft || tab.typeManagementDraft.state === "complete")) return false;
+ if (!tab.typeManagementDraft || tab.typeManagementDraft.state === "complete") assertSourceIdentity(queryStore.getObjectSourceIdentitySnapshot(tab)!);
+ const { connectionId, database, sql } = tab;
+ const owner = source.schema || tab.schema || database;
+ const result = await requestOracleTypeManagement({
+ target: { connectionId, database, owner, name: source.name, databaseType: databaseType as "oracle" | "oceanbase-oracle" | "dameng" },
+ operation: source.objectType === "TYPE_BODY" ? "save-body" : "save-spec",
+ source: sql,
+ baseSource: tab.originalSql,
+ tabId: tab.id,
+ isCurrent: () => queryStore.tabs.includes(tab) && tab.objectSource === source && tab.connectionId === connectionId && tab.database === database && (source.schema || tab.schema || database) === owner && tab.sql === sql,
+ });
+ if (result.complete) toast(t("objects.sourceSaved"), 2000);
+ return result.complete;
+ }
const identity = queryStore.getObjectSourceIdentitySnapshot(tab)!;
assertSourceIdentity(identity);
const { connectionId, database } = tab;
const schema = source.schema || tab.schema || database;
const sql = tab.sql;
- const databaseType = effectiveDatabaseTypeForConnection(connection) ?? connection.db_type;
const statements = await buildExecutableObjectSourceStatements({ databaseType, objectType: source.objectType, schema, name: source.name, source: sql });
save = await prepareObjectSourceSave(connectionId, database, databaseType, statements, schema, { objectType: source.objectType, name: source.name });
const preparedSave = save;
diff --git a/apps/desktop/src/lib/table/oracleTypeDataMapping.ts b/apps/desktop/src/lib/table/oracleTypeDataMapping.ts
new file mode 100644
index 0000000000..99b54bf838
--- /dev/null
+++ b/apps/desktop/src/lib/table/oracleTypeDataMapping.ts
@@ -0,0 +1,221 @@
+import * as api from "@/lib/backend/api";
+import { BackendErrorException, normalizeBackendError } from "@/lib/backend/errorUtils";
+import type { OracleTypeDataManifest, OracleTypeDataMappingInput } from "@/types/database";
+import type { OracleTypeManagementDraft, TypeManagementExecutionOptions } from "./oracleTypeManagement";
+import { typeManagementRecordsEqual as same } from "./oracleTypeManagementRecord";
+
+export interface TypeDataMappingDraft {
+ manifest: OracleTypeDataManifest;
+ insertSql: string;
+ insertDraft?: string;
+ insertState: "not-sent" | "sent" | "confirmed" | "failed" | "unknown";
+ message?: string;
+}
+const clone = <T>(value: T): T => JSON.parse(JSON.stringify(value));
+const mappingIdentity = (mapping: OracleTypeDataMappingInput) => [
+ mapping.id,
+ mapping.source,
+ mapping.old,
+ mapping.expected,
+ mapping.target,
+ mapping.fields.map((field) => [field.sourcePath, field.objectNull, field.oldColumn, field.expectedColumn, field.targetPath, field.targetObjectNull ?? false, field.unchanged]),
+];
+const message = (cause: unknown) => (cause instanceof Error ? cause.message : String(cause));
+const sameRelation = (a: { owner: string; name: string }, b: { owner: string; name: string }) => a.owner === b.owner && a.name === b.name;
+
+/** Register once, while the original live reference and data can still be proved. */
+export async function registerOracleTypeDataBaseline(plan: OracleTypeManagementDraft, mapping: OracleTypeDataMappingInput, persist: TypeManagementExecutionOptions["persist"]): Promise<OracleTypeManagementDraft> {
+ if (plan.steps.some((step) => step.state !== "not-sent") || plan.history.length || plan.dataMappings.some((record) => record.manifest.mapping.id === mapping.id || sameRelation(record.manifest.mapping.source, mapping.source)))
+ throw new Error("The original permanent baseline cannot be replaced after registration or dispatch.");
+ if (!plan.originalSnapshot.persistentReferences.some((reference) => reference.owner === mapping.source.owner && reference.tableName === mapping.source.name)) throw new Error("Select a persistent relation from the original TYPE snapshot.");
+ const result = await api.verifyOracleTypeData({ target: plan.target, action: "register", mapping });
+ if (!result.manifest || !same(mappingIdentity(result.manifest.mapping), mappingIdentity(mapping))) throw new Error("The data baseline was not returned for the registered mapping.");
+ const source = plan.lastSnapshot.objects.find((object) => object.owner === mapping.source.owner && object.name === mapping.source.name && object.objectType === "TABLE");
+ if (source && (source.exists !== true || source.objectId !== result.manifest.original.relation.objectId)) throw new Error("The original table identity changed before baseline registration. Revalidate the TYPE preview.");
+ const next = clone(plan);
+ next.dataMappings.push({ manifest: result.manifest, insertSql: "", insertDraft: "", insertState: "not-sent" });
+ next.dataPreparation = undefined;
+ next.dataTargetPaths = undefined;
+ next.revision++;
+ next.executable = false;
+ next.requiresReverify = true;
+ next.state = "draft";
+ await persist(next);
+ return next;
+}
+
+/** No business rows cross this API. Reopening a tab must reverify these same baselines. */
+export async function verifyOracleTypeDataMappings(plan: OracleTypeManagementDraft): Promise<void> {
+ for (const record of plan.dataMappings) {
+ if (record.insertState === "sent") record.insertState = "unknown";
+ const previous = clone(record.manifest);
+ const result = await api.verifyOracleTypeData({ target: plan.target, action: "verify", manifest: previous });
+ const actual = result.manifest;
+ if (!actual || !actual.verifiedTarget || !same([mappingIdentity(actual.mapping), actual.original, actual.old, actual.expected], [mappingIdentity(previous.mapping), previous.original, previous.old, previous.expected]))
+ throw new Error("The original permanent baseline identity or data changed; do not replace it to resume.");
+ record.manifest = actual;
+ if (["unknown", "sent"].includes(record.insertState)) record.insertState = "confirmed";
+ }
+}
+
+/** Preview and validate against the live empty target; this does not send INSERT. */
+export async function prepareOracleTypeDataInsert(plan: OracleTypeManagementDraft, id: string, sql: string, persist: TypeManagementExecutionOptions["persist"]): Promise<OracleTypeManagementDraft> {
+ const next = clone(plan);
+ const record = next.dataMappings.find((record) => record.manifest.mapping.id === id);
+ if (!record || !["not-sent", "failed"].includes(record.insertState)) throw new Error("A sent INSERT needs readback, not another preview or resend.");
+ const result = await api.verifyOracleTypeData({ target: next.target, action: "validate_insert", manifest: record.manifest, sql });
+ if (!result.manifest?.preparedTarget || !result.insertSql) throw new Error("The complete bounded INSERT and its exact empty target were not verified.");
+ if (!same([mappingIdentity(result.manifest.mapping), result.manifest.original, result.manifest.old, result.manifest.expected], [mappingIdentity(record.manifest.mapping), record.manifest.original, record.manifest.old, record.manifest.expected])) throw new Error("The registered baseline changed.");
+ record.manifest = result.manifest;
+ record.insertSql = result.insertSql;
+ record.insertDraft = result.insertSql;
+ record.insertState = "not-sent";
+ next.executable = false;
+ next.requiresReverify = true;
+ next.revision++;
+ await persist(next);
+ return next;
+}
+
+/** One bounded scalar INSERT, on the normal query boundary and guarded by the
+ * caller. It never drops a relation, changes the TYPE or cleans up baselines. */
+export async function executeOracleTypeDataInsert(plan: OracleTypeManagementDraft, id: string, options: TypeManagementExecutionOptions): Promise<void> {
+ const record = plan.dataMappings.find((record) => record.manifest.mapping.id === id);
+ if (!record?.insertSql || (record.insertDraft ?? record.insertSql) !== record.insertSql || record.insertState !== "not-sent" || !record.manifest.preparedTarget) throw new Error("Preview the bounded INSERT before confirmation.");
+ const checked = await api.verifyOracleTypeData({ target: plan.target, action: "validate_insert", manifest: record.manifest, sql: record.insertSql });
+ const manifestState = (manifest: OracleTypeDataManifest | null | undefined) => manifest && [mappingIdentity(manifest.mapping), manifest.original, manifest.old, manifest.expected, manifest.preparedTarget ?? null, manifest.verifiedTarget ?? null];
+ if (checked.insertSql !== record.insertSql || !same(manifestState(checked.manifest), manifestState(record.manifest))) throw new Error("The prepared INSERT target or statement changed. Preview it again.");
+ if (options.isCurrent?.() === false) throw new Error("The data target changed before confirmation.");
+ const previousState = plan.state;
+ plan.state = "running";
+ record.insertState = "sent";
+ plan.revision++;
+ try {
+ await options.persist(plan);
+ } catch (cause) {
+ record.insertState = "not-sent";
+ plan.state = previousState;
+ throw cause;
+ }
+ if (options.isCurrent?.() === false) {
+ record.insertState = "not-sent";
+ plan.state = previousState;
+ plan.revision++;
+ await options.persist(plan);
+ throw new Error("The data target changed before dispatch.");
+ }
+ let error: unknown;
+ let rejected = false;
+ try {
+ const result = await api.executeQuery(plan.target.connectionId, plan.target.database, record.insertSql, record.manifest.mapping.target.owner);
+ if (result.execution_error || result.messages?.some((item) => item.severity.toUpperCase() === "ERROR")) {
+ rejected = true;
+ throw new BackendErrorException(result.error || "The database rejected the INSERT.");
+ }
+ } catch (cause) {
+ error = cause;
+ const envelope = normalizeBackendError(cause);
+ rejected ||= envelope?.operationOutcome === "not_started" || (envelope?.code === "DBX-JDBC-4001" && envelope.diagnostics?.category === "sql" && envelope.diagnostics?.stage === "execute");
+ }
+ try {
+ const result = await api.verifyOracleTypeData({ target: plan.target, action: "verify", manifest: record.manifest });
+ if (!result.manifest?.verifiedTarget) throw new Error("The complete target data has not been verified.");
+ if (!same([mappingIdentity(result.manifest.mapping), result.manifest.original, result.manifest.old, result.manifest.expected], [mappingIdentity(record.manifest.mapping), record.manifest.original, record.manifest.old, record.manifest.expected]))
+ throw new Error("The original baselines changed during INSERT.");
+ record.manifest = result.manifest;
+ record.insertState = "confirmed";
+ record.message = error ? "Confirmed by complete readback after the response failed." : undefined;
+ } catch (cause) {
+ record.insertState = rejected ? "failed" : "unknown";
+ record.message = message(error ?? cause);
+ }
+ plan.executable = false;
+ plan.requiresReverify = true;
+ plan.state = "stopped";
+ plan.revision++;
+ await options.persist(plan);
+ if (record.insertState !== "confirmed") throw new Error(record.message);
+}
+
+/** Validate the durable record before any restored fields reach a reader. */
+export function isTypeDataMappingDraft(value: unknown): value is TypeDataMappingDraft {
+ if (!value || typeof value !== "object") return false;
+ const record = value as TypeDataMappingDraft;
+ const key = (value: unknown) => {
+ const key = value as { owner: string; name: string };
+ return !!key && typeof key.owner === "string" && typeof key.name === "string";
+ };
+ const path = (value: unknown) => Array.isArray(value) && value.length > 0 && value.length <= 4 && value.every((part) => typeof part === "string" && part.length > 0);
+ const baseline = (value: unknown) => {
+ const baseline = value as OracleTypeDataManifest["old"];
+ const relation = baseline?.relation;
+ return (
+ !!relation &&
+ key(relation.relation) &&
+ typeof relation.objectId === "string" &&
+ typeof relation.structure === "string" &&
+ (relation.readOnly === null || typeof relation.readOnly === "boolean") &&
+ Array.isArray(relation.projection) &&
+ relation.projection.length > 0 &&
+ relation.projection.length <= 128 &&
+ relation.projection.every((field) => field && path(field.path) && typeof field.objectNull === "boolean" && typeof field.dataType === "string") &&
+ Number.isSafeInteger(baseline.rowCount) &&
+ baseline.rowCount >= 0 &&
+ baseline.rowCount <= 10000 &&
+ typeof baseline.fingerprint === "string" &&
+ /^[0-9a-f]{64}$/.test(baseline.fingerprint)
+ );
+ };
+ const manifest = record.manifest;
+ const mapping = manifest?.mapping;
+ return (
+ typeof record.insertSql === "string" &&
+ (record.insertDraft === undefined || typeof record.insertDraft === "string") &&
+ ["not-sent", "sent", "confirmed", "failed", "unknown"].includes(record.insertState) &&
+ !!mapping &&
+ typeof mapping.id === "string" &&
+ mapping.id.length > 0 &&
+ [mapping.source, mapping.old, mapping.expected, mapping.target].every(key) &&
+ Array.isArray(mapping.fields) &&
+ mapping.fields.length > 0 &&
+ mapping.fields.length <= 128 &&
+ mapping.fields.every(
+ (field) =>
+ field &&
+ path(field.sourcePath) &&
+ path(field.targetPath) &&
+ typeof field.objectNull === "boolean" &&
+ (field.targetObjectNull === undefined || typeof field.targetObjectNull === "boolean") &&
+ typeof field.oldColumn === "string" &&
+ typeof field.expectedColumn === "string" &&
+ typeof field.unchanged === "boolean",
+ ) &&
+ [manifest.original, manifest.old, manifest.expected].every(baseline) &&
+ (manifest.preparedTarget == null || baseline(manifest.preparedTarget)) &&
+ (manifest.verifiedTarget == null || baseline(manifest.verifiedTarget))
+ );
+}
+
+export function isTypeDataPreparation(value: unknown): value is OracleTypeDataMappingInput {
+ const mapping = value as OracleTypeDataMappingInput;
+ const relation = (key: { owner: string; name: string }) => key && typeof key.owner === "string" && typeof key.name === "string";
+ const path = (path: string[]) => Array.isArray(path) && path.length > 0 && path.length <= 4 && path.every((part) => typeof part === "string");
+ return (
+ !!mapping &&
+ typeof mapping.id === "string" &&
+ [mapping.source, mapping.old, mapping.expected, mapping.target].every(relation) &&
+ Array.isArray(mapping.fields) &&
+ mapping.fields.length <= 128 &&
+ mapping.fields.every(
+ (field) =>
+ field &&
+ path(field.sourcePath) &&
+ path(field.targetPath) &&
+ typeof field.objectNull === "boolean" &&
+ (field.targetObjectNull === undefined || typeof field.targetObjectNull === "boolean") &&
+ typeof field.oldColumn === "string" &&
+ typeof field.expectedColumn === "string" &&
+ typeof field.unchanged === "boolean",
+ )
+ );
+}
diff --git a/apps/desktop/src/lib/table/oracleTypeManagement.ts b/apps/desktop/src/lib/table/oracleTypeManagement.ts
new file mode 100644
index 0000000000..87c774a494
--- /dev/null
+++ b/apps/desktop/src/lib/table/oracleTypeManagement.ts
@@ -0,0 +1,789 @@
+import * as api from "@/lib/backend/api";
+import { uuid } from "@/lib/common/utils";
+import { BackendErrorException, normalizeBackendError } from "@/lib/backend/errorUtils";
+import { invalidateObjectDdlCache } from "@/lib/metadata/objectDdlCache";
+import { invalidateObjectMetadataCache } from "@/lib/metadata/objectMetadataCache";
+import { freezeSourceIdentities } from "@/lib/table/objectSourceIdentity";
+import { invalidateObjectBrowserRowsCache } from "@/lib/table/objectBrowserRowsCache";
+import { isTypeDataMappingDraft, isTypeDataPreparation, registerOracleTypeDataBaseline, verifyOracleTypeDataMappings, type TypeDataMappingDraft } from "@/lib/table/oracleTypeDataMapping";
+import type { OracleTypeDataMappingInput, OracleTypeEvolutionManifest, TypeExecutionBinding } from "@/types/database";
+import type { DatabaseType, ObjectSourceKind, OracleTypeManagementDependency, OracleTypeManagementObject, OracleTypeManagementObjectKey, OracleTypeManagementPrivilege, OracleTypeManagementSnapshot, OracleTypeManagementSqlInput, OracleTypeManagementTarget, TypeMetadataRead } from "@/types/database";
+
+export type TypeManagementOperation = "save-spec" | "save-body" | "delete-spec" | "delete-body";
+export interface TypeManagementTarget extends OracleTypeManagementTarget {
+ databaseType: Extract<DatabaseType, "oracle" | "oceanbase-oracle" | "dameng">;
+}
+export interface TypeManagementIssue {
+ code: string;
+ message: string;
+ objectKey?: string;
+ repairable: boolean;
+}
+export interface TypeManagementObjectDraft extends OracleTypeManagementObjectKey {
+ source: string;
+}
+export interface TypeManagementStep {
+ id: string;
+ kind: "drop-dependent" | "replace" | "rebuild" | "grant" | "delete" | "evolve" | "compile";
+ object: OracleTypeManagementObjectKey;
+ sql: string;
+ sourceFingerprint?: string;
+ privilege?: OracleTypeManagementPrivilege;
+ nativePhase?: number;
+ triggerEnabled?: boolean;
+ state: "not-sent" | "sent" | "confirmed" | "failed" | "unknown";
+ executionId?: string;
+ databaseTerminal?: boolean;
+ message?: string;
+}
+
+/** Only definitions and control records belong here, never rows from business tables. */
+export interface OracleTypeManagementDraft {
+ version: 1;
+ planId: string;
+ revision: number;
+ target: TypeManagementTarget;
+ operation: TypeManagementOperation;
+ originalSnapshot: OracleTypeManagementSnapshot;
+ lastSnapshot: OracleTypeManagementSnapshot;
+ /** Read-only observation of an unresolved write; never an execution baseline. */
+ observedSnapshot?: OracleTypeManagementSnapshot;
+ drafts: TypeManagementObjectDraft[];
+ steps: TypeManagementStep[];
+ history: TypeManagementStep[];
+ dataMappings: TypeDataMappingDraft[];
+ dataPreparation?: OracleTypeDataMappingInput;
+ dataTargetPaths?: string[];
+ nativeEvolution?: OracleTypeEvolutionManifest;
+ issues: TypeManagementIssue[];
+ executable: boolean;
+ requiresReverify: boolean;
+ state: "draft" | "validated" | "running" | "stopped" | "complete";
+ message?: string;
+}
+
+const sourceKinds = new Set(["TYPE", "TYPE BODY", "PROCEDURE", "FUNCTION", "PACKAGE", "PACKAGE BODY", "VIEW", "TRIGGER"]);
+const canonicalKind = (kind: string) => kind.replaceAll("_", " ").toUpperCase();
+const sourceKind = (kind: string) => canonicalKind(kind).replaceAll(" ", "_") as ObjectSourceKind;
+const clone = <T>(value: T): T => JSON.parse(JSON.stringify(value));
+const errorMessage = (error: unknown) => (error instanceof Error ? error.message : String(error));
+const complete = (read: TypeMetadataRead) => read.state === "available";
+const isBody = (operation: TypeManagementOperation) => operation.endsWith("body");
+const isDelete = (operation: TypeManagementOperation) => operation.startsWith("delete");
+
+function executionBinding(plan: OracleTypeManagementDraft, step: TypeManagementStep): TypeExecutionBinding {
+ return { executionId: step.executionId!, planId: plan.planId, stepId: step.id, connectionId: plan.target.connectionId, database: plan.target.database, schema: step.object.owner, sql: step.sql };
+}
+
+/** The kind and the original quoted spelling are part of the identity. */
+export function typeManagementObjectKey(object: OracleTypeManagementObjectKey): string {
+ return JSON.stringify([object.owner, object.name, canonicalKind(object.objectType)]);
+}
+
+function rootKey(target: TypeManagementTarget, body = false): OracleTypeManagementObjectKey {
+ return { owner: target.owner, name: target.name, objectType: body ? "TYPE BODY" : "TYPE" };
+}
+
+function sameObject(a: OracleTypeManagementObjectKey, b: OracleTypeManagementObjectKey) {
+ return typeManagementObjectKey(a) === typeManagementObjectKey(b);
+}
+
+function objectIn(snapshot: OracleTypeManagementSnapshot, key: OracleTypeManagementObjectKey) {
+ return snapshot.objects.find((object) => sameObject(object, key));
+}
+
+function dependencyKey(edge: OracleTypeManagementDependency) {
+ return JSON.stringify([edge.owner, edge.name, canonicalKind(edge.objectType), edge.referencedOwner, edge.referencedName, canonicalKind(edge.referencedType), edge.referencedLink ?? null]);
+}
+
+function ordered(values: unknown[]) {
+ return values.map((value) => JSON.stringify(value)).sort();
+}
+
+function grants(privileges: OracleTypeManagementPrivilege[]) {
+ return ordered(privileges.map((grant) => [grant.grantor ?? null, grant.grantee, grant.privilege, grant.grantable ?? null, grant.hierarchy ?? null, grant.privilegeType ?? null, grant.columnId ?? null]));
+}
+
+function objectDefinition(object: OracleTypeManagementObject) {
+ return [object.exists ?? null, object.objectId ?? null, object.source ?? null, object.sourceFingerprint ?? null, object.sourceRead.state, grants(object.directPrivileges), object.privilegesRead.state, object.triggerEnabled ?? null, object.triggerEnabledRead?.state ?? null];
+}
+
+/** Compare the live contract, not response order or a digest of ordinary source text. */
+export function typeManagementSnapshotIdentity(snapshot: OracleTypeManagementSnapshot): string {
+ return JSON.stringify([
+ [snapshot.target.connectionId, snapshot.target.database, snapshot.target.owner, snapshot.target.name],
+ snapshot.visibilityScope,
+ snapshot.actingUser ?? null,
+ snapshot.actingUserRead.state,
+ ordered(snapshot.objects.map((object) => [typeManagementObjectKey(object), ...objectDefinition(object), object.status ?? null, object.statusRead.state, ordered(object.errors.map((error) => [error.line, error.position, error.text])), object.errorsRead.state])),
+ snapshot.dependencies.map(dependencyKey).sort(),
+ snapshot.dependenciesRead.state,
+ ordered(snapshot.persistentReferences.map((reference) => [reference.owner, reference.tableName, reference.columnName ?? null, reference.dataTypeOwner ?? null, reference.dataType ?? null, reference.tableReadOnly ?? null])),
+ snapshot.persistentReferencesRead.state,
+ grants(snapshot.directPrivileges),
+ snapshot.privilegesRead.state,
+ ]);
+}
+
+function knownObjects(plan: OracleTypeManagementDraft) {
+ const objects = [...plan.originalSnapshot.objects, ...plan.lastSnapshot.objects, ...plan.drafts];
+ return [...new Map(objects.map((object) => [typeManagementObjectKey(object), { owner: object.owner, name: object.name, objectType: canonicalKind(object.objectType) }])).values()];
+}
+
+async function readSnapshot(target: TypeManagementTarget, known: OracleTypeManagementObjectKey[] = []) {
+ const snapshot = await api.getOracleTypeManagementSnapshot(target.connectionId, target.database, target.owner, target.name, known);
+ if (!sameTarget(snapshot.target, target)) throw new Error("The TYPE snapshot belongs to a different target.");
+ return snapshot;
+}
+
+function sameTarget(a: OracleTypeManagementTarget, b: OracleTypeManagementTarget) {
+ return a.connectionId === b.connectionId && a.database === b.database && a.owner === b.owner && a.name === b.name;
+}
+
+function addIssue(plan: OracleTypeManagementDraft, code: string, message: string, object?: OracleTypeManagementObjectKey, repairable = true) {
+ plan.issues.push({ code, message, objectKey: object && typeManagementObjectKey(object), repairable });
+}
+
+function requireRead(plan: OracleTypeManagementDraft, read: TypeMetadataRead, label: string, object?: OracleTypeManagementObjectKey) {
+ if (!complete(read)) addIssue(plan, "incomplete-metadata", `${label}: ${read.reason || read.state}`, object);
+}
+
+function sourceOrder(plan: OracleTypeManagementDraft, objects: OracleTypeManagementObjectKey[]) {
+ const byKey = new Map(objects.map((object) => [typeManagementObjectKey(object), object]));
+ const precedents = new Map([...byKey.keys()].map((key) => [key, new Set<string>()]));
+ for (const edge of plan.originalSnapshot.dependencies) {
+ const dependent = typeManagementObjectKey(edge);
+ const referenced = typeManagementObjectKey({ owner: edge.referencedOwner, name: edge.referencedName, objectType: edge.referencedType });
+ if (dependent !== referenced && byKey.has(dependent) && byKey.has(referenced)) precedents.get(dependent)!.add(referenced);
+ }
+ for (const object of objects) {
+ if (canonicalKind(object.objectType).endsWith(" BODY")) {
+ const spec = typeManagementObjectKey({ ...object, objectType: canonicalKind(object.objectType).slice(0, -5) });
+ if (byKey.has(spec)) precedents.get(typeManagementObjectKey(object))!.add(spec);
+ }
+ }
+ const output: OracleTypeManagementObjectKey[] = [];
+ while (precedents.size) {
+ const ready = [...precedents]
+ .filter(([, parents]) => !parents.size)
+ .map(([key]) => key)
+ .sort();
+ if (!ready.length) {
+ for (const key of precedents.keys()) addIssue(plan, "dependency-cycle", "The dependency cycle needs revised definitions before a rebuild order can be determined.", byKey.get(key));
+ break;
+ }
+ for (const key of ready) {
+ output.push(byKey.get(key)!);
+ precedents.delete(key);
+ for (const parents of precedents.values()) parents.delete(key);
+ }
+ }
+ return output;
+}
+
+async function buildStep(plan: OracleTypeManagementDraft, object: OracleTypeManagementObjectKey, kind: TypeManagementStep["kind"], input: Omit<OracleTypeManagementSqlInput, "databaseType" | "owner" | "name">, privilege?: OracleTypeManagementPrivilege) {
+ try {
+ const result = await api.buildOracleTypeManagementSql({ databaseType: plan.target.databaseType, owner: object.owner, name: object.name, ...input });
+ if (result.statements.length !== 1 || !result.statements[0]?.trim()) throw new Error("A TYPE step must contain one complete statement.");
+ if (["replace", "rebuild", "compile"].includes(kind) && !result.sourceFingerprint) throw new Error("The complete definition could not be compared after execution.");
+ const sql = result.statements[0];
+ const id = JSON.stringify([kind, typeManagementObjectKey(object), sql]);
+ const previous = plan.steps.find((step) => step.id === id);
+ return { ...previous, id, kind, object: clone(object), sql, sourceFingerprint: result.sourceFingerprint ?? undefined, privilege: privilege && clone(privilege), triggerEnabled: input.triggerEnabled, state: previous?.state ?? "not-sent" } satisfies TypeManagementStep;
+ } catch (error) {
+ addIssue(plan, "invalid-definition", errorMessage(error), object);
+ return null;
+ }
+}
+
+function validateObject(plan: OracleTypeManagementDraft, object: OracleTypeManagementObject) {
+ requireRead(plan, object.statusRead, "Object state", object);
+ if (canonicalKind(object.objectType) === "TRIGGER") {
+ requireRead(plan, object.triggerEnabledRead ?? { state: "unavailable" }, "Trigger enabled state", object);
+ if (typeof object.triggerEnabled !== "boolean") addIssue(plan, "trigger-state", "Read the exact ENABLED/DISABLED trigger state before rebuilding this dependency.", object);
+ }
+ if (!sourceKinds.has(canonicalKind(object.objectType))) {
+ addIssue(plan, "unsupported-dependency", "This dependency needs preparation in the SQL editor; its original identity remains in this plan.", object);
+ return;
+ }
+ requireRead(plan, object.sourceRead, "Complete source", object);
+ if (complete(object.sourceRead) && object.exists !== false && !object.source) addIssue(plan, "missing-source", "The original definition is unavailable. Supply a complete definition and verify its identity.", object);
+}
+
+function restoreGrantIssue(plan: OracleTypeManagementDraft, object: OracleTypeManagementObject, privilege: OracleTypeManagementPrivilege) {
+ if (
+ !complete(plan.lastSnapshot.actingUserRead) ||
+ privilege.grantor !== plan.lastSnapshot.actingUser ||
+ privilege.grantor !== object.owner ||
+ privilege.grantable == null ||
+ privilege.hierarchy !== false ||
+ !["EXECUTE", "DEBUG", "UNDER"].includes(privilege.privilege) ||
+ (plan.target.databaseType === "dameng" && privilege.privilege !== "EXECUTE")
+ ) {
+ addIssue(plan, "grant-authority", "This direct grant needs its original grantor and verified grant options restored before automatic dependency removal.", object);
+ return true;
+ }
+ return false;
+}
+
+/** Preparing never sends SQL. A repairable plan retains every draft and generated step. */
+export async function prepareOracleTypeManagement(target: TypeManagementTarget, operation: TypeManagementOperation, drafts: TypeManagementObjectDraft[] = [], previous?: OracleTypeManagementDraft): Promise<OracleTypeManagementDraft> {
+ if (previous && (!sameTarget(previous.target, target) || previous.target.databaseType !== target.databaseType || previous.operation !== operation)) throw new Error("A recovery plan cannot be rebound to a different TYPE target.");
+ const recoveringSteps = clone(previous?.steps ?? []);
+ for (const step of recoveringSteps) {
+ if (!["sent", "unknown"].includes(step.state) || !step.executionId || step.databaseTerminal) continue;
+ try {
+ const completion = await api.cancelConditionalUpdate(step.executionId, { cancel: false, typeRecovery: executionBinding(previous!, step) });
+ step.databaseTerminal = completion.terminal && completion.databaseTerminal === true;
+ } catch {
+ // A failed status read is not proof that the original DDL has stopped.
+ step.databaseTerminal = false;
+ }
+ }
+ // Never use a snapshot taken before the original execution finished.
+ const actual = await readSnapshot(target, previous ? knownObjects(previous) : []);
+ const started = previous?.steps.some((step) => step.state !== "not-sent") === true || !!previous?.dataMappings?.length;
+ const plan: OracleTypeManagementDraft = {
+ version: 1,
+ planId: previous?.planId ?? uuid(),
+ revision: (previous?.revision ?? 0) + 1,
+ target: clone(target),
+ operation,
+ originalSnapshot: clone(started ? previous!.originalSnapshot : actual),
+ lastSnapshot: clone(actual),
+ drafts: clone(drafts),
+ steps: recoveringSteps,
+ history: clone(previous?.history ?? []),
+ dataMappings: clone(previous?.dataMappings ?? []),
+ dataPreparation: previous?.dataPreparation && clone(previous.dataPreparation),
+ dataTargetPaths: previous?.dataTargetPaths && clone(previous.dataTargetPaths),
+ nativeEvolution: started && previous?.nativeEvolution ? clone(previous.nativeEvolution) : undefined,
+ issues: [],
+ executable: false,
+ requiresReverify: false,
+ state: "draft",
+ };
+ const selected = rootKey(target, isBody(operation));
+ const selectedObject = objectIn(actual, selected);
+ if (!selectedObject) addIssue(plan, "missing-target", "The exact TYPE target could not be read.", selected);
+ else requireRead(plan, selectedObject.statusRead, "Target state", selected);
+ const originalSelected = objectIn(plan.originalSnapshot, selected);
+ if (!originalSelected || originalSelected.exists !== true) addIssue(plan, "missing-target", "The original TYPE target was not verified as existing.", selected);
+ else {
+ requireRead(plan, originalSelected.sourceRead, "Original target source", selected);
+ requireRead(plan, originalSelected.statusRead, "Original target identity", selected);
+ }
+ if (new Set(plan.drafts.map(typeManagementObjectKey)).size !== plan.drafts.length) addIssue(plan, "duplicate-draft", "Keep one definition for each exact owner, name, and object kind.");
+ if (plan.dataMappings.length) {
+ try {
+ await verifyOracleTypeDataMappings(plan);
+ } catch (error) {
+ addIssue(plan, "persistent-data", errorMessage(error));
+ }
+ }
+ const verifiedMapping = (object: OracleTypeManagementObjectKey) =>
+ !plan.issues.some((issue) => issue.code === "persistent-data") && object.objectType === "TABLE" && plan.dataMappings.some((record) => record.manifest.verifiedTarget && record.manifest.mapping.source.owner === object.owner && record.manifest.mapping.source.name === object.name);
+ if (target.databaseType === "oracle" && operation === "save-spec" && !plan.dataMappings.length && (plan.originalSnapshot.persistentReferences.length || plan.nativeEvolution)) {
+ const rootDraft = plan.drafts.find((draft) => sameObject(draft, selected));
+ try {
+ if (!rootDraft || !originalSelected?.source) throw new Error("Supply the complete original and target TYPE specification for native evolution.");
+ const manifest = started ? previous?.nativeEvolution : undefined;
+ if (manifest && rootDraft.source !== manifest.sourceAfter) throw new Error("A dispatched native evolution must retain its approved specification. Reconcile the existing phases before starting another change.");
+ const next = await api.prepareOracleTypeEvolution({ target, sourceBefore: originalSelected.source, sourceAfter: rootDraft.source, manifest });
+ if (!validNativeManifest(next) || !sameTarget(next.target, target) || next.sourceBefore !== originalSelected.source || next.sourceAfter !== rootDraft.source || (manifest && nativeIdentity(next) !== nativeIdentity(manifest)))
+ throw new Error("The native evolution preview changed its original target or guards.");
+ if (manifest && next.phase !== manifest.phase && !previous!.steps.some((step) => step.kind === "evolve" && ["sent", "unknown", "confirmed"].includes(step.state) && step.nativePhase === next.phase))
+ throw new Error("A native evolution phase changed without a recorded dispatch. Reconcile the actual TYPE before continuing.");
+ plan.nativeEvolution = next;
+ } catch (error) {
+ addIssue(plan, "native-evolution", errorMessage(error), selected);
+ }
+ }
+ // A sent or unknown request must first be reconciled, never turned into a new write.
+ for (const step of plan.steps) {
+ if (step.state !== "sent" && step.state !== "unknown") continue;
+ try {
+ if (step.executionId && !step.databaseTerminal) throw new Error("The original database execution has not been confirmed as finished. Keep this plan and read it again after completion.");
+ assertNoUnapprovedChange(previous!.lastSnapshot, actual, step, plan.originalSnapshot);
+ if (stepSatisfied(actual, step, plan.nativeEvolution)) {
+ step.state = "confirmed";
+ step.message = "Confirmed by fresh readback.";
+ } else if (stepWrittenInvalid(actual, step)) {
+ step.state = "failed";
+ step.message = [step.message, invalidDefinitionMessage(objectIn(actual, step.object)!)].filter(Boolean).join("\n");
+ } else throw new Error("A previously sent step is not yet verified. Read back its result; do not resend it.");
+ } catch (error) {
+ addIssue(plan, "unknown-result", errorMessage(error), step.object);
+ }
+ }
+ if (previous && started) {
+ for (const object of previous.lastSnapshot.objects) {
+ const current = objectIn(actual, object);
+ if (verifiedMapping(object)) continue; // external preparation was verified against the original permanent baselines
+ if (current && JSON.stringify(objectDefinition(current)) === JSON.stringify(objectDefinition(object))) continue;
+ const approved = plan.steps.some(
+ (step) =>
+ step.state !== "not-sent" &&
+ (stepSatisfied(actual, step, plan.nativeEvolution) || stepWrittenInvalid(actual, step)) &&
+ (sameObject(step.object, object) || ((step.kind === "delete" || step.kind === "drop-dependent") && step.object.objectType === "TYPE" && object.objectType === "TYPE BODY" && step.object.owner === object.owner && step.object.name === object.name && current?.exists === false)),
+ );
+ if (!approved) addIssue(plan, "definition-changed", "This object's definition, identity, or grants changed after the last recorded state. Review the live definition before starting a replacement plan.", object);
+ }
+ }
+
+ if (plan.steps.some((step) => step.state === "sent" || step.state === "unknown")) {
+ // Keep active execution identities even when the user has edited their drafts.
+ // Replacing these with newly generated steps would lose the no-replay guard.
+ plan.requiresReverify = true;
+ plan.observedSnapshot = clone(actual);
+ plan.lastSnapshot = clone(previous!.lastSnapshot);
+ return plan;
+ }
+ const priorSteps = plan.steps;
+ const generated: TypeManagementStep[] = [];
+ const push = (step: TypeManagementStep | null) => {
+ if (step) generated.push(step);
+ };
+
+ if (isBody(operation)) {
+ const root = objectIn(actual, rootKey(target));
+ if (root?.exists !== true || !complete(root.statusRead)) addIssue(plan, "missing-specification", "The TYPE specification must still exist and have a verified identity.", rootKey(target));
+ if (operation === "delete-body") {
+ requireRead(plan, actual.dependenciesRead, "Deletion impact");
+ push(await buildStep(plan, selected, "delete", { operation: "drop_body" }));
+ } else {
+ const draft = plan.drafts.find((item) => sameObject(item, selected));
+ if (!draft) addIssue(plan, "missing-draft", "Supply the exact TYPE BODY definition.", selected);
+ else push(await buildStep(plan, selected, "replace", { operation: "save_body", source: draft.source }));
+ }
+ } else {
+ requireRead(plan, actual.dependenciesRead, "Dependency closure");
+ requireRead(plan, actual.persistentReferencesRead, "Persistent TYPE references");
+ const unverifiedTables = plan.originalSnapshot.persistentReferences.filter((reference) => !verifiedMapping({ owner: reference.owner, name: reference.tableName, objectType: "TABLE" }));
+ if (!plan.nativeEvolution && (unverifiedTables.length || actual.persistentReferences.length))
+ addIssue(plan, "persistent-mapping", "Register permanent OLD/EXPECTED before external preparation. Verify complete target data and remove live TYPE references in the SQL editor, then revalidate this same plan.");
+ for (const edge of plan.originalSnapshot.dependencies) {
+ if (edge.referencedLink) addIssue(plan, "database-link", "A remote dependency cannot be included in an automatic local rebuild.", edge);
+ }
+ const originals = plan.originalSnapshot.objects.filter((object) => object.exists === true && !verifiedMapping(object) && !(plan.nativeEvolution && object.objectType === "TABLE"));
+ if (plan.originalSnapshot.objects.length > 500) addIssue(plan, "closure-limit", "The TYPE recovery snapshot exceeds the 500-object limit. Reduce the dependency closure before automatic changes.");
+ for (const object of originals) {
+ validateObject(plan, object);
+ if (!plan.drafts.some((draft) => sameObject(draft, object)) && sourceKinds.has(canonicalKind(object.objectType))) plan.drafts.push({ owner: object.owner, name: object.name, objectType: object.objectType, source: object.source ?? "" });
+ }
+ const order = sourceOrder(plan, originals);
+ const dependentTypes = order.filter((object) => canonicalKind(object.objectType) === "TYPE" && !sameObject(object, selected));
+ for (const key of plan.nativeEvolution ? [] : dependentTypes) {
+ const object = objectIn(plan.originalSnapshot, key)!;
+ requireRead(plan, object.privilegesRead, "Direct grants", object);
+ for (const privilege of object.directPrivileges) restoreGrantIssue(plan, object, privilege);
+ }
+ for (const object of plan.nativeEvolution ? [] : dependentTypes.slice().reverse()) push(await buildStep(plan, object, "drop-dependent", { operation: "drop_spec" }));
+ if (plan.nativeEvolution) {
+ plan.nativeEvolution.statements.forEach((sql, index) => {
+ const id = JSON.stringify(["evolve", typeManagementObjectKey(selected), sql]);
+ const previous = plan.steps.find((step) => step.id === id);
+ push({ ...previous, id, kind: "evolve", object: clone(selected), sql, nativePhase: index + 1, state: previous?.state ?? "not-sent" });
+ });
+ } else if (!isDelete(operation)) {
+ const draft = plan.drafts.find((item) => sameObject(item, selected));
+ if (!draft) addIssue(plan, "missing-draft", "Supply the exact TYPE specification.", selected);
+ else push(await buildStep(plan, selected, "replace", { operation: "save_spec", source: draft.source }));
+ }
+ for (const object of order) {
+ if (sameObject(object, selected) || (isDelete(operation) && sameObject(object, rootKey(target, true)))) continue;
+ const draft = plan.drafts.find((item) => sameObject(item, object));
+ if (!draft) continue;
+ if (isDelete(operation)) {
+ const directlyReferencesRoot = plan.originalSnapshot.dependencies.some((edge) => sameObject(edge, object) && edge.referencedOwner === target.owner && edge.referencedName === target.name && canonicalKind(edge.referencedType) === "TYPE");
+ const original = objectIn(plan.originalSnapshot, object)!;
+ if (directlyReferencesRoot && draft.source === original.source) addIssue(plan, "unlink-required", "Revise this definition to use the chosen replacement TYPE, then revalidate. The original TYPE will be dropped only after live references are removed.", object);
+ }
+ if (plan.nativeEvolution && object.objectType === "TYPE") {
+ const step = await buildStep(plan, object, "compile", { operation: "compile_spec", source: draft.source });
+ if (step && step.sourceFingerprint !== objectIn(plan.originalSnapshot, object)?.sourceFingerprint) addIssue(plan, "native-dependent-edit", "Keep this dependent TYPE specification unchanged for native compilation. Evolve its structure in a separate verified plan.", object);
+ push(step);
+ } else {
+ const original = objectIn(plan.originalSnapshot, object)!;
+ const unchangedTrigger = object.objectType === "TRIGGER" && draft.source === original.source;
+ push(
+ await buildStep(plan, object, unchangedTrigger ? "compile" : "rebuild", {
+ operation: unchangedTrigger ? "compile_trigger" : "rebuild_source",
+ objectType: sourceKind(object.objectType),
+ source: draft.source,
+ triggerEnabled: object.objectType === "TRIGGER" ? (original.triggerEnabled ?? undefined) : undefined,
+ }),
+ );
+ }
+ if (!plan.nativeEvolution && canonicalKind(object.objectType) === "TYPE") {
+ const original = objectIn(plan.originalSnapshot, object)!;
+ for (const privilege of original.directPrivileges) {
+ if (!plan.issues.some((issue) => issue.code === "grant-authority" && issue.objectKey === typeManagementObjectKey(object)))
+ push(await buildStep(plan, object, "grant", { operation: "grant_privilege", grantee: privilege.grantee, grantable: privilege.grantable!, privilege: privilege.privilege }, privilege));
+ }
+ }
+ }
+ if (isDelete(operation)) push(await buildStep(plan, selected, "delete", { operation: "drop_spec" }));
+ }
+
+ // Keep failed diagnostics before revalidation resets the step, and sent history when drafts change.
+ for (const step of priorSteps.filter((step) => step.state !== "not-sent")) {
+ const changed = !generated.some((candidate) => candidate.id === step.id);
+ if (step.state === "failed" || (changed && !plan.history.some((attempt) => attempt.id === step.id))) plan.history.push(clone(step));
+ if (changed && step.state !== "failed") addIssue(plan, "changed-sent-step", "A sent definition changed. Verify the original step before replacing its draft.", step.object);
+ }
+ plan.steps = generated;
+ for (const step of plan.steps) {
+ if (step.state === "confirmed" && !stepStillSatisfied(actual, step, plan.steps, plan.nativeEvolution)) addIssue(plan, "confirmed-step-changed", "A confirmed result no longer matches the approved definition. Review the actual state before continuing.", step.object);
+ if (step.state === "failed") {
+ step.state = "not-sent"; // a verified failure is retryable only after fresh confirmation
+ delete step.executionId;
+ delete step.databaseTerminal;
+ }
+ }
+ plan.executable = !plan.issues.length;
+ plan.state = plan.executable ? (plan.steps.every((step) => step.state === "confirmed") ? "complete" : "validated") : "draft";
+ return plan;
+}
+
+function stepSatisfied(snapshot: OracleTypeManagementSnapshot, step: TypeManagementStep, native?: OracleTypeEvolutionManifest) {
+ const object = objectIn(snapshot, step.object);
+ if (!object || !complete(object.statusRead)) return false;
+ if (step.kind === "delete" || step.kind === "drop-dependent") return object.exists === false;
+ if (step.kind === "grant") return complete(object.privilegesRead) && object.directPrivileges.some((privilege) => grants([privilege])[0] === grants([step.privilege!])[0]);
+ if (step.object.objectType === "TRIGGER" && (typeof step.triggerEnabled !== "boolean" || object.triggerEnabled !== step.triggerEnabled || !complete(object.triggerEnabledRead ?? { state: "unavailable" }))) return false;
+ if (step.kind === "evolve") return !!native && !!step.nativePhase && native.phase >= step.nativePhase && object.exists === true && object.status === "VALID" && complete(object.sourceRead) && complete(object.errorsRead) && !object.errors.length;
+ return object.exists === true && object.status === "VALID" && complete(object.sourceRead) && complete(object.errorsRead) && !object.errors.length && object.sourceFingerprint === step.sourceFingerprint;
+}
+
+function stepWrittenInvalid(snapshot: OracleTypeManagementSnapshot, step: TypeManagementStep) {
+ const object = objectIn(snapshot, step.object);
+ return (
+ step.databaseTerminal === true &&
+ ["replace", "rebuild", "compile"].includes(step.kind) &&
+ !!step.sourceFingerprint &&
+ object?.exists === true &&
+ object.status === "INVALID" &&
+ complete(object.statusRead) &&
+ complete(object.sourceRead) &&
+ complete(object.errorsRead) &&
+ object.sourceFingerprint === step.sourceFingerprint &&
+ (step.object.objectType !== "TRIGGER" || (typeof step.triggerEnabled === "boolean" && object.triggerEnabled === step.triggerEnabled && complete(object.triggerEnabledRead ?? { state: "unavailable" })))
+ );
+}
+
+function invalidDefinitionMessage(object: OracleTypeManagementObject) {
+ return `Written, but INVALID. ${object.errors.map((error) => `${error.line}:${error.position} ${error.text}`).join(" ") || "The error dictionary returned no diagnostics."}`;
+}
+
+function stepStillSatisfied(snapshot: OracleTypeManagementSnapshot, step: TypeManagementStep, steps: TypeManagementStep[], native?: OracleTypeEvolutionManifest) {
+ if (step.kind === "drop-dependent") {
+ const rebuild = steps.find((candidate) => sameObject(candidate.object, step.object) && candidate.kind === "rebuild");
+ if (rebuild && rebuild.state !== "not-sent") {
+ const actual = objectIn(snapshot, step.object);
+ return actual?.exists === false || (complete(actual?.sourceRead ?? { state: "unavailable" }) && actual?.sourceFingerprint === rebuild.sourceFingerprint);
+ }
+ }
+ // A later specification replacement may invalidate a BODY which is still awaiting its planned rebuild.
+ return stepSatisfied(snapshot, step, native);
+}
+
+function assertNoUnapprovedChange(before: OracleTypeManagementSnapshot, after: OracleTypeManagementSnapshot, step: TypeManagementStep, original: OracleTypeManagementSnapshot) {
+ if ((complete(before.dependenciesRead) && !complete(after.dependenciesRead)) || (complete(before.persistentReferencesRead) && !complete(after.persistentReferencesRead))) throw new Error("Dependency or persistent-reference readback is incomplete. Verify the applied step before continuing.");
+ if (["replace", "rebuild", "compile", "evolve"].includes(step.kind)) {
+ const old = objectIn(before, step.object);
+ const actual = objectIn(after, step.object);
+ if (!old || !actual || grants(old.directPrivileges).join() !== grants(actual.directPrivileges).join() || old.privilegesRead.state !== actual.privilegesRead.state) throw new Error("The source replacement did not preserve direct grants.");
+ }
+ if (step.kind === "grant") {
+ const old = objectIn(before, step.object);
+ const actual = objectIn(after, step.object);
+ const expected = new Set(grants([...(old?.directPrivileges ?? []), step.privilege!]));
+ const observed = JSON.stringify(grants(actual?.directPrivileges ?? []));
+ const approved = [JSON.stringify(grants(old?.directPrivileges ?? [])), JSON.stringify([...expected].sort())];
+ if (!old || !actual || old.exists !== actual.exists || old.objectId !== actual.objectId || old.source !== actual.source || !complete(actual.privilegesRead) || !approved.includes(observed)) throw new Error("The grant readback contains an unapproved identity, definition, or grant change.");
+ }
+ for (const object of before.objects) {
+ if (sameObject(object, step.object)) continue;
+ if ((step.kind === "delete" || step.kind === "drop-dependent") && step.object.objectType === "TYPE" && object.objectType === "TYPE BODY" && object.owner === step.object.owner && object.name === step.object.name) continue;
+ const actual = objectIn(after, object);
+ if (!actual || JSON.stringify(objectDefinition(actual)) !== JSON.stringify(objectDefinition(object))) throw new Error(`${object.objectType} ${object.owner}.${object.name} changed outside the approved step.`);
+ }
+ // Restoring a removed TYPE can make its old caller edges visible again.
+ const oldEdges = new Set([...before.dependencies, ...original.dependencies].map(dependencyKey));
+ if (after.dependencies.some((edge) => !oldEdges.has(dependencyKey(edge)) && !sameObject(edge, step.object))) throw new Error("A new dependency appeared outside the approved step.");
+ if (JSON.stringify(ordered(after.persistentReferences)) !== JSON.stringify(ordered(before.persistentReferences))) throw new Error("Persistent TYPE references changed during execution.");
+}
+
+export interface TypeManagementExecutionOptions {
+ /** Must save this exact revision through app_state and read it back, or reject. */
+ persist: (draft: OracleTypeManagementDraft) => Promise<void>;
+ /** Relevant only before dispatch. Confirmed writes stay bound to their original target. */
+ isCurrent?: () => boolean;
+ shouldStop?: () => boolean;
+}
+
+export async function registerOracleTypeDataMapping(plan: OracleTypeManagementDraft, mapping: OracleTypeDataMappingInput, persist: TypeManagementExecutionOptions["persist"]): Promise<OracleTypeManagementDraft> {
+ const assertOriginal = async () => {
+ const actual = await readSnapshot(plan.target, knownObjects(plan));
+ if (typeManagementSnapshotIdentity(actual) !== typeManagementSnapshotIdentity(plan.lastSnapshot)) throw new Error("TYPE metadata changed before baseline registration. Revalidate the preview before preparing permanent baselines.");
+ };
+ await assertOriginal();
+ return registerOracleTypeDataBaseline(plan, mapping, async (record) => {
+ await assertOriginal();
+ await persist(record);
+ });
+}
+
+export class OracleTypeManagementFailure extends Error {
+ constructor(
+ public readonly plan: OracleTypeManagementDraft,
+ cause: unknown,
+ ) {
+ super(errorMessage(cause));
+ }
+}
+
+function nativeIdentity(value: OracleTypeEvolutionManifest) {
+ return JSON.stringify([[value.target.connectionId, value.target.database, value.target.owner, value.target.name], value.sourceBefore, value.sourceAfter, value.statements, value.metadata]);
+}
+function validNativeManifest(value: OracleTypeEvolutionManifest) {
+ return (
+ !!value &&
+ !!value.target &&
+ [value.target.connectionId, value.target.database, value.target.owner, value.target.name, value.sourceBefore, value.sourceAfter, value.metadata].every((part) => typeof part === "string" && part.length > 0) &&
+ Array.isArray(value.statements) &&
+ value.statements.length <= 2 &&
+ value.statements.every((sql) => typeof sql === "string" && sql.length > 0) &&
+ Number.isSafeInteger(value.phase) &&
+ value.phase >= 0 &&
+ value.phase <= value.statements.length
+ );
+}
+async function refreshNative(plan: OracleTypeManagementDraft, allowedPhases: number[]) {
+ const manifest = plan.nativeEvolution;
+ if (!manifest) return;
+ const actual = await api.prepareOracleTypeEvolution({ target: plan.target, sourceBefore: manifest.sourceBefore, sourceAfter: manifest.sourceAfter, manifest });
+ if (!validNativeManifest(actual) || nativeIdentity(actual) !== nativeIdentity(manifest) || !allowedPhases.includes(actual.phase)) throw new Error("The native evolution phase, table identity, counts or restrictions changed outside the approved step.");
+ plan.nativeEvolution = actual;
+}
+
+/** Each DDL uses the existing session boundary. No transaction or rollback is promised. */
+export async function executeOracleTypeManagement(plan: OracleTypeManagementDraft, options: TypeManagementExecutionOptions): Promise<OracleTypeManagementDraft> {
+ if (!plan.executable || plan.requiresReverify || plan.state === "complete") throw new Error("Revalidate the TYPE plan before execution.");
+ if (options.isCurrent?.() === false) throw new Error("The TYPE target or draft changed before confirmation.");
+ const frozen = freezeSourceIdentities(knownObjects(plan).map((object) => ({ connectionId: plan.target.connectionId, database: plan.target.database, schema: object.owner, name: object.name, objectType: sourceKind(object.objectType) })));
+ let dispatched = false;
+ plan.state = "running";
+ try {
+ const initial = await readSnapshot(plan.target, knownObjects(plan));
+ if (typeManagementSnapshotIdentity(initial) !== typeManagementSnapshotIdentity(plan.lastSnapshot)) throw new Error("TYPE definitions, dependencies, or grants changed. Revalidate the preview.");
+ await refreshNative(plan, [plan.nativeEvolution?.phase ?? 0]);
+ for (const step of plan.steps) {
+ if (step.state === "confirmed") continue;
+ if (step.state !== "not-sent") throw new Error("A previously sent step needs readback, not another execution.");
+ if (options.shouldStop?.()) throw new Error("Stopped before the next step; confirmed DDL remains applied.");
+ if (!dispatched && options.isCurrent?.() === false) throw new Error("The TYPE target or draft changed before dispatch.");
+ const before = await readSnapshot(plan.target, knownObjects(plan));
+ if (typeManagementSnapshotIdentity(before) !== typeManagementSnapshotIdentity(plan.lastSnapshot)) throw new Error("TYPE metadata changed before the next step. Revalidate the remaining plan.");
+ await refreshNative(plan, [plan.nativeEvolution?.phase ?? 0]);
+ await verifyOracleTypeDataMappings(plan);
+ if (step.kind === "delete" && step.object.objectType === "TYPE") {
+ if (!complete(before.dependenciesRead) || !complete(before.persistentReferencesRead) || before.persistentReferences.length) throw new Error("Verify all persistent references before deleting the TYPE.");
+ const references = before.dependencies.filter(
+ (edge) => edge.referencedOwner === step.object.owner && edge.referencedName === step.object.name && canonicalKind(edge.referencedType) === "TYPE" && !(edge.owner === step.object.owner && edge.name === step.object.name && ["TYPE", "TYPE BODY"].includes(canonicalKind(edge.objectType))),
+ );
+ if (references.length) throw new Error("The TYPE still has live dependents. Revise their definitions and revalidate before DROP.");
+ }
+ plan.revision++;
+ step.state = "sent";
+ step.executionId = uuid();
+ step.databaseTerminal = false;
+ try {
+ await options.persist(plan);
+ } catch (error) {
+ step.state = "not-sent";
+ throw error;
+ }
+ if (!dispatched && options.isCurrent?.() === false) {
+ step.state = "not-sent";
+ throw new Error("The TYPE target or draft changed before dispatch.");
+ }
+ frozen.markDispatched();
+ dispatched = true;
+ let executionError: unknown;
+ let rejected = false;
+ try {
+ const result = await api.executeConditionalUpdate(plan.target.connectionId, plan.target.database, step.sql, step.object.owner, step.executionId, { typeRecovery: { planId: plan.planId, stepId: step.id } });
+ step.databaseTerminal = true;
+ if (result.execution_error || result.messages?.some((message) => message.severity.toUpperCase() === "ERROR")) {
+ rejected = true;
+ throw new BackendErrorException(result.error || "The database rejected the TYPE statement.");
+ }
+ } catch (error) {
+ executionError = error;
+ const envelope = normalizeBackendError(error);
+ // A terminal, typed execute rejection can be reviewed and retried. Fetch,
+ // timeout and legacy text errors do not prove that the DDL has stopped.
+ rejected ||= envelope?.operationOutcome === "not_started" || (envelope?.code === "DBX-JDBC-4001" && envelope.diagnostics?.category === "sql" && envelope.diagnostics?.stage === "execute");
+ step.databaseTerminal ||= rejected;
+ }
+ if (!step.databaseTerminal) {
+ try {
+ const completion = await api.cancelConditionalUpdate(step.executionId, { cancel: false, typeRecovery: executionBinding(plan, step) });
+ step.databaseTerminal = completion.terminal && completion.databaseTerminal === true;
+ } catch {
+ // Keep the original execution unknown when its completion cannot be read.
+ }
+ }
+ try {
+ const after = await readSnapshot(plan.target, knownObjects(plan));
+ await refreshNative(plan, step.kind === "evolve" ? [plan.nativeEvolution!.phase, step.nativePhase!] : [plan.nativeEvolution?.phase ?? 0]);
+ const satisfied = step.databaseTerminal && stepSatisfied(after, step, plan.nativeEvolution);
+ assertNoUnapprovedChange(before, after, step, plan.originalSnapshot);
+ await verifyOracleTypeDataMappings(plan);
+ plan.lastSnapshot = clone(after);
+ if (!satisfied) {
+ const object = objectIn(after, step.object);
+ const original = objectIn(before, step.object);
+ const unchanged = object && original && JSON.stringify(objectDefinition(object)) === JSON.stringify(objectDefinition(original));
+ const writtenInvalid = stepWrittenInvalid(after, step);
+ // A different VALID definition, or a success without its expected
+ // effect, is not a retryable rejection. Reconcile it before any send.
+ step.state = writtenInvalid || (rejected && unchanged) ? "failed" : "unknown";
+ step.message = executionError
+ ? [errorMessage(executionError), writtenInvalid ? invalidDefinitionMessage(object!) : undefined].filter(Boolean).join("\n")
+ : object?.status === "INVALID"
+ ? invalidDefinitionMessage(object)
+ : "The write result has not been verified against the approved definition.";
+ throw new Error(step.message);
+ }
+ step.state = "confirmed";
+ step.message = [executionError ? "Confirmed by readback after the response failed." : undefined, objectIn(after, step.object)?.errorsRead.reason].filter(Boolean).join("\n") || undefined;
+ plan.revision++;
+ await options.persist(plan);
+ } catch (error) {
+ if (step.state === "sent") step.state = "unknown";
+ step.message ||= errorMessage(error);
+ throw error;
+ }
+ }
+ if (!plan.steps.every((step) => stepStillSatisfied(plan.lastSnapshot, step, plan.steps, plan.nativeEvolution))) throw new Error("A completed definition or grant no longer matches the approved TYPE plan. Read back before continuing.");
+ plan.state = "complete";
+ plan.executable = false;
+ plan.revision++;
+ await options.persist(plan);
+ return plan;
+ } catch (error) {
+ plan.state = "stopped";
+ plan.executable = false;
+ plan.requiresReverify = true;
+ plan.message = errorMessage(error);
+ plan.revision++;
+ try {
+ await options.persist(plan);
+ } catch (persistError) {
+ plan.message += ` Recovery record was not saved: ${errorMessage(persistError)}`;
+ }
+ throw new OracleTypeManagementFailure(plan, error);
+ } finally {
+ if (!dispatched) frozen.cancel();
+ else {
+ frozen.finish();
+ const affected = knownObjects(plan);
+ for (const owner of new Set(affected.map((object) => object.owner))) invalidateObjectBrowserRowsCache({ connectionId: plan.target.connectionId, database: plan.target.database, schema: owner });
+ await Promise.allSettled(
+ affected.flatMap((object) => {
+ const scope = { connectionId: plan.target.connectionId, database: plan.target.database, schema: object.owner, tableName: object.name };
+ return [invalidateObjectDdlCache(scope), invalidateObjectMetadataCache(scope)];
+ }),
+ );
+ }
+ }
+}
+
+/** Restored SQL is a draft, never executable authority. Fresh preparation rebuilds every statement. */
+export function restoreOracleTypeManagementDraft(value: unknown): OracleTypeManagementDraft | undefined {
+ if (!value || typeof value !== "object") return undefined;
+ const draft = value as OracleTypeManagementDraft;
+ const target = draft.target;
+ const validKey = (object: OracleTypeManagementObjectKey) => object && typeof object.owner === "string" && typeof object.name === "string" && typeof object.objectType === "string";
+ const optionalString = (value: unknown) => value == null || typeof value === "string";
+ const validRead = (read: TypeMetadataRead) => read && ["available", "incomplete", "unavailable", "unsupported"].includes(read.state) && optionalString(read.reason);
+ const validGrant = (grant: OracleTypeManagementPrivilege) =>
+ grant && typeof grant.grantee === "string" && typeof grant.privilege === "string" && optionalString(grant.grantor) && (grant.grantable == null || typeof grant.grantable === "boolean") && (grant.hierarchy == null || typeof grant.hierarchy === "boolean");
+ const validObject = (object: OracleTypeManagementObject) =>
+ validKey(object) &&
+ (object.exists == null || typeof object.exists === "boolean") &&
+ optionalString(object.objectId) &&
+ optionalString(object.status) &&
+ (object.triggerEnabled == null || typeof object.triggerEnabled === "boolean") &&
+ (object.triggerEnabledRead == null || validRead(object.triggerEnabledRead)) &&
+ optionalString(object.source) &&
+ optionalString(object.sourceFingerprint) &&
+ [object.sourceRead, object.statusRead, object.errorsRead, object.privilegesRead].every(validRead) &&
+ Array.isArray(object.errors) &&
+ object.errors.every((error) => Number.isSafeInteger(error.line) && error.line >= 0 && Number.isSafeInteger(error.position) && error.position >= 0 && typeof error.text === "string") &&
+ Array.isArray(object.directPrivileges) &&
+ object.directPrivileges.every(validGrant);
+ const validSnapshot = (snapshot: OracleTypeManagementSnapshot) =>
+ snapshot &&
+ typeof snapshot.visibilityScope === "string" &&
+ optionalString(snapshot.actingUser) &&
+ [snapshot.actingUserRead, snapshot.detailsRead, snapshot.typeSourceRead, snapshot.bodySourceRead, snapshot.dependenciesRead, snapshot.persistentReferencesRead, snapshot.privilegesRead].every(validRead) &&
+ Array.isArray(snapshot.objects) &&
+ snapshot.objects.every(validObject) &&
+ new Set(snapshot.objects.map(typeManagementObjectKey)).size === snapshot.objects.length &&
+ Array.isArray(snapshot.dependencies) &&
+ snapshot.dependencies.every((edge) => validKey(edge) && typeof edge.referencedOwner === "string" && typeof edge.referencedName === "string" && typeof edge.referencedType === "string" && optionalString(edge.referencedLink)) &&
+ Array.isArray(snapshot.persistentReferences) &&
+ snapshot.persistentReferences.every((reference) => reference && typeof reference.owner === "string" && typeof reference.tableName === "string") &&
+ Array.isArray(snapshot.directPrivileges) &&
+ snapshot.directPrivileges.every(validGrant) &&
+ snapshot.target &&
+ sameTarget(snapshot.target, target);
+ const validStep = (step: TypeManagementStep) =>
+ step &&
+ validKey(step.object) &&
+ typeof step.id === "string" &&
+ typeof step.sql === "string" &&
+ ["drop-dependent", "replace", "rebuild", "grant", "delete", "evolve", "compile"].includes(step.kind) &&
+ ["not-sent", "sent", "confirmed", "failed", "unknown"].includes(step.state) &&
+ optionalString(step.sourceFingerprint) &&
+ optionalString(step.executionId) &&
+ (step.databaseTerminal === undefined || typeof step.databaseTerminal === "boolean") &&
+ (step.databaseTerminal !== true || !!step.executionId) &&
+ (step.triggerEnabled === undefined || typeof step.triggerEnabled === "boolean") &&
+ (step.kind !== "evolve" || (Number.isSafeInteger(step.nativePhase) && step.nativePhase! > 0 && step.nativePhase! <= 2)) &&
+ (step.kind !== "grant" || validGrant(step.privilege!));
+ if (
+ draft.version !== 1 ||
+ typeof draft.planId !== "string" ||
+ !draft.planId ||
+ !Number.isSafeInteger(draft.revision) ||
+ draft.revision < 1 ||
+ !target ||
+ !["oracle", "oceanbase-oracle", "dameng"].includes(target.databaseType) ||
+ ![target.connectionId, target.database, target.owner, target.name].every((part) => typeof part === "string") ||
+ !["save-spec", "save-body", "delete-spec", "delete-body"].includes(draft.operation)
+ )
+ return undefined;
+ if (![draft.originalSnapshot, draft.lastSnapshot].every(validSnapshot)) return undefined;
+ if (draft.observedSnapshot !== undefined && !validSnapshot(draft.observedSnapshot)) return undefined;
+ if (!Array.isArray(draft.drafts) || !draft.drafts.every((object) => validKey(object) && typeof object.source === "string") || !Array.isArray(draft.steps) || !draft.steps.every(validStep) || (draft.history !== undefined && (!Array.isArray(draft.history) || !draft.history.every(validStep))))
+ return undefined;
+ if (draft.dataMappings !== undefined && (!Array.isArray(draft.dataMappings) || !draft.dataMappings.every(isTypeDataMappingDraft) || new Set(draft.dataMappings.map((record) => record.manifest.mapping.id)).size !== draft.dataMappings.length)) return undefined;
+ if (draft.dataPreparation !== undefined && !isTypeDataPreparation(draft.dataPreparation)) return undefined;
+ if (draft.dataTargetPaths !== undefined && (!Array.isArray(draft.dataTargetPaths) || draft.dataTargetPaths.length > 128 || !draft.dataTargetPaths.every((value) => typeof value === "string"))) return undefined;
+ if (draft.nativeEvolution !== undefined && (!validNativeManifest(draft.nativeEvolution) || !sameTarget(draft.nativeEvolution.target, target) || target.databaseType !== "oracle" || draft.operation !== "save-spec" || draft.dataMappings?.length)) return undefined;
+ const restored = clone(draft);
+ restored.history ??= [];
+ restored.dataMappings ??= [];
+ for (const record of restored.dataMappings) if (record.insertState === "sent") record.insertState = "unknown";
+ restored.executable = false;
+ restored.requiresReverify = true;
+ restored.state = draft.state === "complete" ? "complete" : "stopped";
+ restored.issues = [];
+ for (const step of restored.steps) if (step.state === "sent") step.state = "unknown";
+ return restored;
+}
diff --git a/apps/desktop/src/lib/table/oracleTypeManagementRecord.ts b/apps/desktop/src/lib/table/oracleTypeManagementRecord.ts
new file mode 100644
index 0000000000..436d62deac
--- /dev/null
+++ b/apps/desktop/src/lib/table/oracleTypeManagementRecord.ts
@@ -0,0 +1,17 @@
+/** SQLite JSON storage and Rust serializers may reorder object properties, but
+ * recovery definitions, baselines and ordered step states must survive intact. */
+export function typeManagementRecordsEqual(left: unknown, right: unknown): boolean {
+ function canonical(value: unknown): unknown {
+ if (Array.isArray(value)) return value.map(canonical);
+ if (value && typeof value === "object") {
+ const record = value as Record<string, unknown>;
+ return Object.fromEntries(
+ Object.keys(record)
+ .sort()
+ .map((key) => [key, canonical(record[key])]),
+ );
+ }
+ return value;
+ }
+ return JSON.stringify(canonical(left)) === JSON.stringify(canonical(right));
+}
diff --git a/apps/desktop/src/lib/table/oracleTypeManagementRequest.ts b/apps/desktop/src/lib/table/oracleTypeManagementRequest.ts
new file mode 100644
index 0000000000..f1823a3414
--- /dev/null
+++ b/apps/desktop/src/lib/table/oracleTypeManagementRequest.ts
@@ -0,0 +1,41 @@
+import { readonly, shallowRef } from "vue";
+import { uuid } from "@/lib/common/utils";
+import type { OracleTypeManagementSnapshot } from "@/types/database";
+import type { TypeManagementOperation, TypeManagementTarget } from "@/lib/table/oracleTypeManagement";
+
+export interface TypeManagementRequest {
+ id: string;
+ target: TypeManagementTarget;
+ operation: TypeManagementOperation;
+ source?: string;
+ baseSource?: string;
+ tabId?: string;
+ isCurrent?: () => boolean;
+}
+export interface TypeManagementOutcome {
+ complete: boolean;
+ target: TypeManagementTarget;
+ operation: TypeManagementOperation;
+ snapshot?: OracleTypeManagementSnapshot;
+}
+
+const current = shallowRef<TypeManagementRequest | null>(null);
+let resolveCurrent: ((outcome: TypeManagementOutcome) => void) | undefined;
+export const oracleTypeManagementRequest = readonly(current);
+
+/** The existing navigation surfaces share one confirmation surface and one durable source tab. */
+export function requestOracleTypeManagement(input: Omit<TypeManagementRequest, "id">): Promise<TypeManagementOutcome> {
+ if (current.value) return Promise.reject(new Error("Finish or close the current TYPE preview before starting another."));
+ return new Promise((resolve) => {
+ resolveCurrent = resolve;
+ current.value = { ...input, target: { ...input.target }, id: uuid() };
+ });
+}
+
+export function finishOracleTypeManagementRequest(id: string, outcome: TypeManagementOutcome) {
+ if (current.value?.id !== id) return;
+ const resolve = resolveCurrent;
+ resolveCurrent = undefined;
+ current.value = null;
+ resolve?.(outcome);
+}
diff --git a/apps/desktop/src/stores/__tests__/connectionStore.metadataLoading.spec.ts b/apps/desktop/src/stores/__tests__/connectionStore.metadataLoading.spec.ts
index 04b049c60d..c4dc6f2140 100644
--- a/apps/desktop/src/stores/__tests__/connectionStore.metadataLoading.spec.ts
+++ b/apps/desktop/src/stores/__tests__/connectionStore.metadataLoading.spec.ts
@@ -4693,6 +4693,7 @@ describe("connectionStore metadata loading", () => {
checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
getCustomTypeDetails,
+ listInstalledAgents: vi.fn().mockResolvedValue([]),
loadSchemaCache: vi.fn().mockResolvedValue(null),
saveSchemaCache: vi.fn().mockResolvedValue(undefined),
saveConnections: vi.fn().mockResolvedValue(undefined),
@@ -4743,6 +4744,148 @@ describe("connectionStore metadata loading", () => {
expect(store.isTreeNodeChildrenLoaded(typeNode.id)).toBe(true);
});
+ it("loads Oracle TYPE attributes on demand, caches known-empty results, retries failures, and ignores stale detail responses", async () => {
+ let resolveStale!: (value: any) => void;
+ const stale = new Promise((resolve) => {
+ resolveStale = resolve;
+ });
+ const oracleDetails = (attributes: any[]) => ({
+ name: "TYPE_OBJ",
+ schema: "APP",
+ kind: "object",
+ members: [],
+ oracleMetadata: {
+ attributesRead: { state: "available" },
+ methodsRead: { state: "available" },
+ propertiesRead: { state: "available" },
+ collectionRead: { state: "unsupported" },
+ bodyRead: { state: "unsupported" },
+ attributes,
+ methods: [],
+ },
+ });
+ const getCustomTypeDetails = vi
+ .fn()
+ .mockResolvedValueOnce(oracleDetails([]))
+ .mockRejectedValueOnce(new Error("temporary catalog failure"))
+ .mockResolvedValueOnce(oracleDetails([{ name: "STREET", ordinal: 1, typeName: "VARCHAR2" }]))
+ .mockReturnValueOnce(stale)
+ .mockResolvedValueOnce(oracleDetails([{ name: "CITY", ordinal: 1, typeName: "VARCHAR2" }]));
+
+ vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+ vi.doMock("@/lib/backend/api", () => ({
+ checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
+ deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
+ getCustomTypeDetails,
+ listInstalledAgents: vi.fn().mockResolvedValue([]),
+ loadSchemaCache: vi.fn().mockResolvedValue(null),
+ saveSchemaCache: vi.fn().mockResolvedValue(undefined),
+ saveConnections: vi.fn().mockResolvedValue(undefined),
+ saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
+ }));
+
+ const { useConnectionStore } = await import("@/stores/connectionStore");
+ const store = useConnectionStore();
+ const connection = oracleConnection();
+ const typeNode: TreeNode = {
+ id: `${connection.id}:XE:APP:TYPE_OBJ`,
+ label: "TYPE_OBJ",
+ objectName: "TYPE_OBJ",
+ type: "type",
+ connectionId: connection.id,
+ database: "XE",
+ schema: "APP",
+ children: undefined,
+ };
+ store.connections = [connection];
+ store.connectedIds.add(connection.id);
+ store.treeNodes = [{ id: connection.id, label: connection.name, type: "connection", connectionId: connection.id, children: [typeNode] }];
+
+ await store.loadCustomTypeChildren(typeNode, { force: true });
+ expect(typeNode.hasMembers).toBe(false);
+ expect(typeNode.children).toEqual([]);
+ await expect(store.loadCustomTypeChildren(typeNode, { force: true })).rejects.toThrow("temporary catalog failure");
+ await store.loadCustomTypeChildren(typeNode, { force: true });
+ expect(typeNode.hasMembers).toBe(true);
+ expect(typeNode.children?.map((child) => child.label)).toEqual(["STREET"]);
+
+ const staleLoad = store.loadCustomTypeChildren(typeNode, { force: true });
+ await vi.waitFor(() => expect(getCustomTypeDetails).toHaveBeenCalledTimes(4));
+ await store.loadCustomTypeChildren(typeNode, { force: true });
+ resolveStale(oracleDetails([{ name: "STALE", ordinal: 1, typeName: "VARCHAR2" }]));
+ await staleLoad;
+ expect(typeNode.children?.map((child) => child.label)).toEqual(["CITY"]);
+ expect(typeNode.hasMembers).toBe(true);
+ });
+
+ it("keeps Oracle attributes unknown and retryable when a successful detail DTO reports unavailable or incomplete reads", async () => {
+ const oracleDetails = (read: { state: string; reason?: string }, attributes: any[]) => ({
+ name: "TYPE_OBJ",
+ schema: "APP",
+ kind: "object",
+ members: [],
+ oracleMetadata: {
+ attributesRead: read,
+ methodsRead: { state: "available" },
+ propertiesRead: { state: "available" },
+ collectionRead: { state: "unsupported" },
+ bodyRead: { state: "unsupported" },
+ attributes,
+ methods: [],
+ },
+ });
+ const getCustomTypeDetails = vi
+ .fn()
+ .mockResolvedValueOnce(oracleDetails({ state: "unavailable", reason: "Dictionary access denied." }, []))
+ .mockResolvedValueOnce(oracleDetails({ state: "incomplete", reason: "One attribute row could not be read." }, [{ name: "STREET", ordinal: 1, typeName: "VARCHAR2" }]))
+ .mockResolvedValueOnce(oracleDetails({ state: "available" }, []));
+
+ vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+ vi.doMock("@/lib/backend/api", () => ({
+ checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
+ deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
+ getCustomTypeDetails,
+ listInstalledAgents: vi.fn().mockResolvedValue([]),
+ loadSchemaCache: vi.fn().mockResolvedValue(null),
+ saveSchemaCache: vi.fn().mockResolvedValue(undefined),
+ saveConnections: vi.fn().mockResolvedValue(undefined),
+ saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
+ }));
+
+ const { useConnectionStore } = await import("@/stores/connectionStore");
+ const store = useConnectionStore();
+ const connection = oracleConnection();
+ const typeNode: TreeNode = {
+ id: `${connection.id}:XE:APP:TYPE_OBJ`,
+ label: "TYPE_OBJ",
+ objectName: "TYPE_OBJ",
+ type: "type",
+ connectionId: connection.id,
+ database: "XE",
+ schema: "APP",
+ children: undefined,
+ };
+ store.connections = [connection];
+ store.connectedIds.add(connection.id);
+ store.treeNodes = [{ id: connection.id, label: connection.name, type: "connection", connectionId: connection.id, children: [typeNode] }];
+
+ await store.loadCustomTypeChildren(typeNode);
+ expect(typeNode.hasMembers).toBeUndefined();
+ expect(typeNode.children).toEqual([]);
+ expect(store.isTreeNodeChildrenLoaded(typeNode.id)).toBe(false);
+
+ await store.loadCustomTypeChildren(typeNode);
+ expect(typeNode.hasMembers).toBeUndefined();
+ expect(typeNode.children?.map((child) => child.label)).toEqual(["STREET"]);
+ expect(store.isTreeNodeChildrenLoaded(typeNode.id)).toBe(false);
+
+ await store.loadCustomTypeChildren(typeNode);
+ expect(typeNode.hasMembers).toBe(false);
+ expect(typeNode.children).toEqual([]);
+ expect(store.isTreeNodeChildrenLoaded(typeNode.id)).toBe(true);
+ expect(getCustomTypeDetails).toHaveBeenCalledTimes(3);
+ });
+
it("loads more object group children for catalogless databases with empty database string", async () => {
const firstPageTables = Array.from({ length: 201 }, (_, i) => ({
name: `t_${String(i + 1).padStart(4, "0")}`,
diff --git a/apps/desktop/src/stores/__tests__/queryStore.hiddenPrimaryKey.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.hiddenPrimaryKey.spec.ts
index 0c9d849a0d..cab02d237e 100644
--- a/apps/desktop/src/stores/__tests__/queryStore.hiddenPrimaryKey.spec.ts
+++ b/apps/desktop/src/stores/__tests__/queryStore.hiddenPrimaryKey.spec.ts
@@ -2,31 +2,8 @@ import { createPinia, setActivePinia } from "pinia";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { saveVirtualRowIdentifier } from "@/lib/table/virtualRowIdentifier";
-const localStorageValues = new Map<string, string>();
-vi.stubGlobal("localStorage", {
- getItem: (key: string) => localStorageValues.get(key) ?? null,
- setItem: (key: string, value: string) => localStorageValues.set(key, value),
- removeItem: (key: string) => localStorageValues.delete(key),
-});
-
-const {
- executeMulti,
- executeQuery,
- beginManualTransaction,
- executeInManualTransaction,
- cancelQuery,
- analyzeEditableQueryEditability,
- getColumns,
- listIndexes,
- listObjects,
- listTables,
- getConnectionConfig,
- lookupLocalCompletionTables,
- buildSortedQuerySql,
- buildDataGridCountSql,
- prepareQueryPaginationExecutionPlan,
- editorSettings,
-} = vi.hoisted(() => ({
+const apiMocks = vi.hoisted(() => ({
+ localStorageValues: new Map<string, string>(),
executeMulti: vi.fn(),
executeQuery: vi.fn(),
beginManualTransaction: vi.fn(),
@@ -41,7 +18,7 @@ const {
lookupLocalCompletionTables: vi.fn(),
buildSortedQuerySql: vi.fn(),
buildDataGridCountSql: vi.fn(),
- prepareQueryPaginationExecutionPlan: vi.fn(async (options) => ({
+ prepareQueryPaginationExecutionPlan: vi.fn(async (options: { sql: string }) => ({
sqlToExecute: options.sql,
pageSql: undefined,
pageLimit: undefined,
@@ -56,6 +33,30 @@ const {
queryResultMaxRows: 100_000,
},
}));
+const {
+ localStorageValues,
+ executeMulti,
+ executeQuery,
+ beginManualTransaction,
+ executeInManualTransaction,
+ cancelQuery,
+ analyzeEditableQueryEditability,
+ getColumns,
+ listIndexes,
+ listObjects,
+ listTables,
+ getConnectionConfig,
+ lookupLocalCompletionTables,
+ buildSortedQuerySql,
+ buildDataGridCountSql,
+ prepareQueryPaginationExecutionPlan,
+ editorSettings,
+} = apiMocks;
+vi.stubGlobal("localStorage", {
+ getItem: (key: string) => localStorageValues.get(key) ?? null,
+ setItem: (key: string, value: string) => localStorageValues.set(key, value),
+ removeItem: (key: string) => localStorageValues.delete(key),
+});
function deferred<T>() {
let resolve!: (value: T) => void;
@@ -66,29 +67,29 @@ function deferred<T>() {
}
vi.mock("@/lib/backend/api", () => ({
- analyzeEditableQueryEditability,
- buildDataGridCountSql,
- buildSortedQuerySql,
+ analyzeEditableQueryEditability: apiMocks.analyzeEditableQueryEditability,
+ buildDataGridCountSql: apiMocks.buildDataGridCountSql,
+ buildSortedQuerySql: apiMocks.buildSortedQuerySql,
closeClientConnectionSession: vi.fn().mockResolvedValue(undefined),
closeQuerySession: vi.fn().mockResolvedValue(undefined),
- beginManualTransaction,
- cancelQuery,
- executeInManualTransaction,
- executeMulti,
- executeQuery,
- getColumns,
- listIndexes,
- listObjects,
- listTables,
- prepareQueryPaginationExecutionPlan,
+ beginManualTransaction: apiMocks.beginManualTransaction,
+ cancelQuery: apiMocks.cancelQuery,
+ executeInManualTransaction: apiMocks.executeInManualTransaction,
+ executeMulti: apiMocks.executeMulti,
+ executeQuery: apiMocks.executeQuery,
+ getColumns: apiMocks.getColumns,
+ listIndexes: apiMocks.listIndexes,
+ listObjects: apiMocks.listObjects,
+ listTables: apiMocks.listTables,
+ prepareQueryPaginationExecutionPlan: apiMocks.prepareQueryPaginationExecutionPlan,
saveOpenTabsState: vi.fn().mockResolvedValue(undefined),
}));
vi.mock("@/stores/connectionStore", () => ({
useConnectionStore: () => ({
ensureConnected: vi.fn().mockResolvedValue(undefined),
- getConfig: getConnectionConfig,
- lookupLocalCompletionTables,
+ getConfig: apiMocks.getConnectionConfig,
+ lookupLocalCompletionTables: apiMocks.lookupLocalCompletionTables,
recordConnectionLostError: vi.fn(),
// 与真实 store 一致:setTableMeta 写入 tableMeta 时记录连接元数据代次
metadataGenerationFor: () => 0,
@@ -97,7 +98,7 @@ vi.mock("@/stores/connectionStore", () => ({
vi.mock("@/stores/settingsStore", () => ({
useSettingsStore: () => ({
- editorSettings,
+ editorSettings: apiMocks.editorSettings,
}),
}));
diff --git a/apps/desktop/src/stores/__tests__/queryStore.typeManagement.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.typeManagement.spec.ts
new file mode 100644
index 0000000000..ecef97a33d
--- /dev/null
+++ b/apps/desktop/src/stores/__tests__/queryStore.typeManagement.spec.ts
@@ -0,0 +1,267 @@
+// @vitest-environment happy-dom
+import { createPinia, disposePinia, setActivePinia } from "pinia";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { OracleTypeManagementDraft } from "@/lib/table/oracleTypeManagement";
+import type { ConnectionConfig, OracleTypeManagementSnapshot } from "@/types/database";
+
+const mocks = vi.hoisted(() => ({ save: vi.fn(), load: vi.fn(), snapshot: vi.fn(), build: vi.fn(), getSource: vi.fn(), editableSource: vi.fn() }));
+vi.mock("@/lib/backend/api", async (importOriginal) => ({
+ ...(await importOriginal<typeof import("@/lib/backend/api")>()),
+ saveOpenTabsState: mocks.save,
+ loadOpenTabsState: mocks.load,
+ getOracleTypeManagementSnapshot: mocks.snapshot,
+ buildOracleTypeManagementSql: mocks.build,
+ getObjectSource: mocks.getSource,
+ buildEditableObjectSource: mocks.editableSource,
+ checkConnectionHealth: vi.fn(async () => {}),
+ closeClientConnectionSession: vi.fn(async () => true),
+ listDetachedTabHandoffs: vi.fn(async () => []),
+ subscribeConnectionLiveness: vi.fn(async () => () => {}),
+ subscribeConnectionIdleClosed: vi.fn(async () => () => {}),
+}));
+
+const target = { connectionId: "type-persist-test", database: "db", owner: "Mixed Owner", name: "Mixed Type", databaseType: "oceanbase-oracle" as const };
+const source = 'CREATE OR REPLACE TYPE "Mixed Owner"."Mixed Type" AS OBJECT (ID NUMBER);';
+const read = { state: "available" as const };
+const clone = <T>(value: T): T => JSON.parse(JSON.stringify(value));
+let saved: { tabs: unknown[]; activeTabId: string | null };
+let pinia: ReturnType<typeof createPinia>;
+
+function snapshot(): OracleTypeManagementSnapshot {
+ return {
+ target: { connectionId: target.connectionId, database: target.database, owner: target.owner, name: target.name },
+ visibilityScope: "current-user-visible-dictionaries",
+ actingUser: target.owner,
+ actingUserRead: read,
+ detailsRead: read,
+ typeSource: source,
+ typeSourceRead: read,
+ bodySource: null,
+ bodySourceRead: read,
+ objects: [{ owner: target.owner, name: target.name, objectType: "TYPE", exists: true, objectId: "9007199254740993", status: "VALID", statusRead: read, source, sourceRead: read, sourceFingerprint: source, errors: [], errorsRead: read, directPrivileges: [], privilegesRead: read }],
+ dependencies: [],
+ dependenciesRead: read,
+ persistentReferences: [],
+ persistentReferencesRead: read,
+ directPrivileges: [],
+ privilegesRead: read,
+ };
+}
+
+beforeEach(() => {
+ vi.resetModules();
+ vi.unstubAllGlobals();
+ vi.clearAllMocks();
+ vi.stubGlobal(
+ "EventSource",
+ class extends EventTarget {
+ onmessage = null;
+ onerror = null;
+ close() {}
+ },
+ );
+ vi.stubGlobal("localStorage", { getItem: vi.fn(() => null), setItem: vi.fn(), removeItem: vi.fn() });
+ vi.stubGlobal(
+ "fetch",
+ vi.fn(async (url, init) => {
+ if (String(url).endsWith("/api/tab-runtime-cache/prune")) return new Response(JSON.stringify({ deletedEntries: 0, deletedBytes: 0, orphanDeletions: 0, remainingEntries: 0, remainingBytes: 0 }), { status: 200 });
+ if (String(url).startsWith("/api/tab-runtime-cache?key=") && init?.method === "DELETE") return new Response(null, { status: 204 });
+ throw new Error(`Unmocked HTTP boundary: ${String(url)}`);
+ }),
+ );
+ pinia = createPinia();
+ setActivePinia(pinia);
+ saved = { tabs: [], activeTabId: null };
+ mocks.save.mockImplementation(async (payload) => {
+ saved = clone(payload);
+ });
+ mocks.load.mockImplementation(async () => clone(saved));
+ mocks.snapshot.mockImplementation(async () => snapshot());
+ mocks.build.mockImplementation(async (input) => ({ statements: [input.source], sourceFingerprint: input.source }));
+ mocks.editableSource.mockImplementation(async (input) => input.source);
+});
+
+afterEach(async () => {
+ disposePinia(pinia);
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ expect(
+ vi
+ .mocked(fetch)
+ .mock.calls.filter(([url, init]) => !String(url).endsWith("/api/tab-runtime-cache/prune") && !(String(url).startsWith("/api/tab-runtime-cache?key=") && init?.method === "DELETE"))
+ .map(([url]) => String(url)),
+ ).toEqual([]);
+ vi.unstubAllGlobals();
+});
+
+async function setup(loaded = true) {
+ const { useQueryStore } = await import("@/stores/queryStore");
+ const store = useQueryStore();
+ if (loaded) await store.initOpenTabs();
+ const tabId = store.openObjectSourceTab({ connectionId: target.connectionId, database: target.database, schema: target.owner, title: "TYPE source", sql: source, objectSource: { schema: target.owner, name: target.name, objectType: "TYPE" } });
+ const { prepareOracleTypeManagement } = await import("@/lib/table/oracleTypeManagement");
+ const plan = await prepareOracleTypeManagement(target, "save-spec", [{ owner: target.owner, name: target.name, objectType: "TYPE", source }]);
+ return { store, tabId, plan };
+}
+
+describe("durable TYPE recovery through the real query store", () => {
+ it.each([
+ ["oracle", "TYPE"],
+ ["oracle", "TYPE_BODY"],
+ ["oceanbase-oracle", "TYPE"],
+ ["oceanbase-oracle", "TYPE_BODY"],
+ ["dameng", "TYPE"],
+ ["dameng", "TYPE_BODY"],
+ ] as const)("opens %s %s read-only by default with an explicit edit state and no generic SQL bypass", async (databaseType, objectType) => {
+ const { useConnectionStore } = await import("@/stores/connectionStore");
+ const connections = useConnectionStore();
+ connections.connections.push({ id: target.connectionId, name: "test", db_type: databaseType } as ConnectionConfig);
+ connections.connectedIds.add(target.connectionId);
+ mocks.getSource.mockResolvedValue({ name: target.name, object_type: objectType, source, editable: true });
+ const { useQueryStore } = await import("@/stores/queryStore");
+ const store = useQueryStore();
+ await store.initOpenTabs();
+ const id = store.openObjectSourceTabPending({ connectionId: target.connectionId, database: target.database, schema: target.owner, title: "TYPE", initialEditing: false, request: { name: target.name, objectType } });
+ await vi.waitFor(() => expect(store.tabs.find((tab) => tab.id === id)?.objectSource?.objectType).toBe(objectType));
+ const tab = store.tabs.find((tab) => tab.id === id)!;
+ expect(tab.sourceView).toBe(true);
+ expect(tab.typeSourceEditing).toBe(false);
+ expect(tab.objectDetails).toMatchObject({ connectionId: target.connectionId, database: target.database, schema: target.owner, name: target.name, objectType, section: "source" });
+ await expect(store.executeTabSql(id, source)).rejects.toThrow();
+ tab.typeSourceEditing = true;
+ expect(tab.objectSource?.objectType).toBe(objectType);
+ });
+ it("awaits app_state saving and reads back the exact plan revision through the real serializer", async () => {
+ const { store, tabId, plan } = await setup();
+ mocks.save.mockClear();
+ mocks.load.mockClear();
+ await store.persistTypeManagementDraft(tabId, plan);
+ expect(mocks.save).toHaveBeenCalledOnce();
+ expect(mocks.load).toHaveBeenCalledOnce();
+ const tab = saved.tabs.find((value) => (value as { id: string }).id === tabId) as { typeManagementDraft: OracleTypeManagementDraft; objectDetails: unknown };
+ expect(tab.typeManagementDraft.planId).toBe(plan.planId);
+ expect(tab.typeManagementDraft.revision).toBe(plan.revision);
+ expect(tab.typeManagementDraft.originalSnapshot.objects[0].objectId).toBe("9007199254740993");
+ expect(tab.typeManagementDraft.drafts[0].source).toBe(source);
+ const { restoreOpenTabsPayload } = await import("@/lib/app/openTabsPersistence");
+ const restored = restoreOpenTabsPayload(saved).tabs.find((value) => value.id === tabId)!;
+ expect(restored.objectDetails).toEqual(tab.objectDetails);
+ expect(restored.objectDetails).toMatchObject({ name: target.name, schema: target.owner, objectType: "TYPE", section: "source" });
+ expect(restored.typeManagementDraft?.planId).toBe(plan.planId);
+ expect(restored.typeManagementDraft?.requiresReverify).toBe(true);
+ expect(restored.typeSourceEditing).toBe(false);
+ expect(store.tabs[0].sql).toBe(store.tabs[0].originalSql);
+ expect(store.isTabDirty(store.tabs[0])).toBe(true);
+ });
+
+ it("rejects failed saving and a stale readback instead of reporting an empty success", async () => {
+ const { store, tabId, plan } = await setup();
+ mocks.save.mockRejectedValueOnce(new Error("disk full"));
+ await expect(store.persistTypeManagementDraft(tabId, plan)).rejects.toThrow("disk full");
+ mocks.load.mockResolvedValueOnce({ tabs: [], activeTabId: null });
+ await expect(store.persistTypeManagementDraft(tabId, plan)).rejects.toThrow("app_state");
+ });
+
+ it("rejects an incomplete recovery payload even when its plan id and revision still match", async () => {
+ const { store, tabId, plan } = await setup();
+ const damaged = clone(plan);
+ damaged.drafts[0].source = "A stored draft was lost";
+ mocks.load.mockResolvedValueOnce({ tabs: [{ id: tabId, typeManagementDraft: damaged }], activeTabId: tabId });
+ await expect(store.persistTypeManagementDraft(tabId, plan)).rejects.toThrow("app_state");
+ });
+
+ it("rejects unloaded, pending-source, mismatched or closed tabs before saving", async () => {
+ const { store, tabId, plan } = await setup(false);
+ await expect(store.persistTypeManagementDraft(tabId, plan)).rejects.toThrow("loaded main workspace");
+ await store.initOpenTabs();
+ const id = store.openObjectSourceTab({ connectionId: target.connectionId, database: target.database, schema: target.owner, title: "TYPE source", sql: source, objectSource: { schema: target.owner, name: target.name, objectType: "TYPE" } });
+ const tab = store.tabs.find((item) => item.id === id)!;
+ tab.sourceLoad = { startedAt: 1, request: { name: target.name, objectType: "TYPE" } };
+ await expect(store.persistTypeManagementDraft(id, plan)).rejects.toThrow("durable source tab");
+ tab.sourceLoad = undefined;
+ await expect(store.persistTypeManagementDraft(id, { ...plan, target: { ...target, owner: "OTHER" } })).rejects.toThrow("durable source tab");
+ store.closeTab(id, { force: true });
+ await expect(store.persistTypeManagementDraft(id, plan)).rejects.toThrow("durable source tab");
+ });
+
+ it.each(["none", "pinned"] as const)("retains an unfinished recovery manifest when ordinary tab restoration is %s", async (openTabsRestoreMode) => {
+ const { store, tabId, plan } = await setup();
+ const key = (name: string) => ({ owner: target.owner, name });
+ const baseline = (name: string, rowCount: number, readOnly: boolean) => ({
+ relation: { relation: key(name), objectId: "9007199254740993", readOnly, structure: `${name}-definition`, projection: [{ path: ["ID"], objectNull: false, dataType: "NUMBER(38,0)" }] },
+ rowCount,
+ fingerprint: "d".repeat(64),
+ });
+ const mapping = { id: "same-permanent-mapping", source: key("SRC"), old: key("OLD"), expected: key("EXPECTED"), target: key("RESULT"), fields: [{ sourcePath: ["ID"], objectNull: false, oldColumn: "ID", expectedColumn: "ID", targetPath: ["ID"], targetObjectNull: false, unchanged: true }] };
+ plan.dataMappings = [
+ { manifest: { mapping, original: baseline("SRC", 3, false), old: baseline("OLD", 3, true), expected: baseline("EXPECTED", 3, true), preparedTarget: baseline("RESULT", 0, false) }, insertSql: "bounded INSERT preview", insertDraft: "bounded INSERT preview", insertState: "sent" },
+ ];
+ plan.dataPreparation = { ...clone(mapping), id: "next-mapping", source: key("NEXT") };
+ plan.dataTargetPaths = ['["ID"]'];
+ plan.steps[0].state = "sent";
+ await store.persistTypeManagementDraft(tabId, plan);
+ disposePinia(pinia);
+ pinia = createPinia();
+ setActivePinia(pinia);
+ const { useSettingsStore } = await import("@/stores/settingsStore");
+ useSettingsStore().updateEditorSettings({ openTabsRestoreMode });
+ const { useQueryStore } = await import("@/stores/queryStore");
+ const restored = useQueryStore();
+ await restored.initOpenTabs();
+ expect(restored.tabs).toHaveLength(1);
+ expect(restored.tabs[0].id).toBe(tabId);
+ const record = restored.tabs[0].typeManagementDraft!;
+ expect(record.planId).toBe(plan.planId);
+ expect(record.executable).toBe(false);
+ expect(record.requiresReverify).toBe(true);
+ expect(record.steps[0].state).toBe("unknown");
+ expect(record.originalSnapshot.objects[0].objectId).toBe("9007199254740993");
+ expect(record.dataMappings[0].insertState).toBe("unknown");
+ expect(record.dataMappings[0].manifest).toEqual(plan.dataMappings[0].manifest);
+ expect(record.dataPreparation).toEqual(plan.dataPreparation);
+ expect(record.dataTargetPaths).toEqual(plan.dataTargetPaths);
+ });
+
+ it("protects tab closure and detachment independently of ordinary dirty-SQL settings", async () => {
+ const { store, tabId, plan } = await setup();
+ const { useSettingsStore } = await import("@/stores/settingsStore");
+ useSettingsStore().updateEditorSettings({ confirmUnsavedSqlClose: false, appCloseUnsavedTabsMode: "prompt" });
+ await store.persistTypeManagementDraft(tabId, plan);
+ await expect(store.prepareDetachedTab(tabId)).rejects.toThrow("main workspace");
+ store.closeTab(tabId);
+ expect(store.showCloseConfirm).toBe(true);
+ expect(store.closeConfirmDirtyTabIds).toEqual([tabId]);
+ store.cancelClosePendingTab();
+ expect(store.tabs.some((tab) => tab.id === tabId)).toBe(true);
+ expect(store.requiresAppCloseDraftPersist).toBe(true);
+ expect(store.requestAppCloseConfirmation()).toBe(false);
+ });
+
+ it("rejects a different live plan and will not overwrite its original definitions", async () => {
+ const { store, tabId, plan } = await setup();
+ await store.persistTypeManagementDraft(tabId, plan);
+ await expect(store.persistTypeManagementDraft(tabId, { ...clone(plan), planId: "other-plan" })).rejects.toThrow("existing TYPE recovery plan");
+ expect(store.tabs[0].typeManagementDraft?.planId).toBe(plan.planId);
+ });
+
+ it("does not allow generic SQL execution or forced tab closure to discard an in-flight recovery record", async () => {
+ const { store, tabId, plan } = await setup();
+ plan.state = "running";
+ plan.steps[0].state = "sent";
+ await store.persistTypeManagementDraft(tabId, plan);
+ await expect(store.executeTabSql(tabId, source)).rejects.toThrow();
+ store.closeTab(tabId, { force: true });
+ expect(store.tabs.some((tab) => tab.id === tabId)).toBe(true);
+ expect(store.tabs[0].typeManagementDraft?.steps[0].state).toBe("sent");
+ });
+
+ it("preserves an existing recovery record during a pending source reload but does not permit another write", async () => {
+ const { store, tabId, plan } = await setup();
+ await store.persistTypeManagementDraft(tabId, plan);
+ store.tabs[0].sourceLoad = { startedAt: 1, request: { name: target.name, objectType: "TYPE" } };
+ await store.flushPendingPersist();
+ const persisted = saved.tabs.find((tab) => (tab as { id: string }).id === tabId) as { sourceLoad?: unknown; typeManagementDraft: OracleTypeManagementDraft };
+ expect(persisted.typeManagementDraft.planId).toBe(plan.planId);
+ expect(persisted.sourceLoad).toBeUndefined();
+ await expect(store.persistTypeManagementDraft(tabId, plan)).rejects.toThrow("durable source tab");
+ });
+});
diff --git a/apps/desktop/src/stores/connectionStore.ts b/apps/desktop/src/stores/connectionStore.ts
index b37caab47e..2fa03463bc 100644
--- a/apps/desktop/src/stores/connectionStore.ts
+++ b/apps/desktop/src/stores/connectionStore.ts
@@ -7438,8 +7438,10 @@ export const useConnectionStore = defineStore("connection", () => {
if (!targetNode) return;
const children = buildCustomTypeTreeChildren(targetNode, details);
targetNode.customTypeKind = details.kind;
- targetNode.hasMembers = children.length > 0;
+ const attributesRead = details.oracleMetadata?.attributesRead;
+ targetNode.hasMembers = attributesRead && attributesRead.state !== "available" ? undefined : children.length > 0;
setChildren(targetNode, children);
+ if (attributesRead && attributesRead.state !== "available") clearLoadedChildrenCache(targetNode.id);
targetNode.isExpanded = children.length > 0;
} catch (error) {
recordMetadataLoadError(node.connectionId, error, load);
diff --git a/apps/desktop/src/stores/queryStore.ts b/apps/desktop/src/stores/queryStore.ts
index edf9024ff1..b90ed65c84 100644
--- a/apps/desktop/src/stores/queryStore.ts
+++ b/apps/desktop/src/stores/queryStore.ts
@@ -157,6 +157,9 @@ import { sqlTextFingerprint } from "@/lib/sql/sqlTextFingerprint";
import { loadEditableObjectSourceForEditor } from "@/lib/table/objectSourceLoad";
import { assertSourceIdentity, captureSourceIdentity, renewSourceIdentity, type SourceIdentitySnapshot } from "@/lib/table/objectSourceIdentity";
import { buildEditableObjectSource, prepareRoutineSourceRun, supportsRoutineSourceReplaceOnRun } from "@/lib/table/objectSourceEditor";
+import { restoreOracleTypeManagementDraft, type OracleTypeManagementDraft } from "@/lib/table/oracleTypeManagement";
+import { typeManagementRecordsEqual } from "@/lib/table/oracleTypeManagementRecord";
+import { isOracleFamilyTypeSource } from "@/lib/database/databaseObjectCapabilities";
import { disposeAllSqlServerActivityTraces, disposeSqlServerActivityTrace } from "@/lib/sqlserver/sqlServerActivityTraceRuntime";
import type { SavedSqlFile } from "@/types/database";
import i18n, { currentLocale } from "@/i18n";
@@ -1073,11 +1076,8 @@ function restoreSavedTabsFromPayload(
options: { validConnectionIds?: Iterable<string> } = {},
): { tabs: QueryTab[]; activeTabId: string | null; workspace?: unknown } {
const restoreMode = safeLocalStorageGet(UPDATE_RESTORE_KEY) === "1" ? "all" : useSettingsStore().editorSettings.openTabsRestoreMode;
- if (restoreMode === "none") {
- return { tabs: [], activeTabId: null, workspace: undefined };
- }
const restored = restoreOpenTabsPayload(payload, {
- filter: restoreMode === "pinned" ? "pinned" : "all",
+ filter: restoreMode === "none" ? "recovery" : restoreMode === "pinned" ? "pinned" : "all",
validConnectionIds: options.validConnectionIds,
});
return {
@@ -1726,6 +1726,7 @@ export const useQueryStore = defineStore("query", () => {
function createMultiDbExecutionWorker(sourceTabId: string, target: MultiDbExecutionTarget, scopeId: string): string | undefined {
const source = tabs.value.find((tab) => tab.id === sourceTabId);
+ if (source && (source.typeManagementDraft || isOracleFamilyTypeSource(effectiveDatabaseTypeForConnection(useConnectionStore().getConfig(source.connectionId)), source.objectSource?.objectType))) throw new Error(t("objects.typeManagementUseSave"));
if (!source) return undefined;
const id = `multi-worker-${uuid()}`;
const worker = reactive<QueryTab>({
@@ -2863,6 +2864,7 @@ export const useQueryStore = defineStore("query", () => {
structureDraft: t.structureDraft,
objectBrowser: t.objectBrowser,
objectSource: t.objectSource,
+ typeManagementDraft: t.typeManagementDraft,
sourceView: t.sourceView,
objectDetails: t.objectDetails,
tableMeta: t.tableMeta,
@@ -2935,9 +2937,58 @@ export const useQueryStore = defineStore("query", () => {
return saveTabs(tabs.value, activeTabId.value, { groups: groups.value, focusedGroupId: focusedGroupId.value, orientation: orientation.value, sizes: sizes.value });
}
+ async function persistTypeManagementDraft(tabId: string, draft: OracleTypeManagementDraft): Promise<void> {
+ if (isDetachedWindow() || storePersistGeneration !== persistGeneration || !isOpenTabsLoaded.value) throw new Error("TYPE recovery records must be saved from the loaded main workspace.");
+ const tab = tabs.value.find((candidate) => candidate.id === tabId);
+ const kind = draft.operation.endsWith("body") ? "TYPE_BODY" : "TYPE";
+ if (
+ !tab ||
+ tab.mode !== "query" ||
+ tab.sourceLoad ||
+ tab.isDefaultQuery ||
+ tab.detachedConnectionName ||
+ tab.connectionId !== draft.target.connectionId ||
+ tab.database !== draft.target.database ||
+ tab.objectSource?.name !== draft.target.name ||
+ tab.objectSource.objectType !== kind ||
+ (tab.objectSource.schema || tab.schema || tab.database) !== draft.target.owner
+ )
+ throw new Error("The durable source tab no longer matches this TYPE plan.");
+ if (tab.typeManagementDraft && tab.typeManagementDraft.state !== "complete" && tab.typeManagementDraft.planId !== draft.planId) throw new Error("Continue or explicitly discard the existing TYPE recovery plan first.");
+ const record = JSON.parse(JSON.stringify(draft)) as OracleTypeManagementDraft;
+ if (!restoreOracleTypeManagementDraft(record)) throw new Error("The TYPE recovery record is incomplete.");
+ tab.typeManagementDraft = record;
+ if (persistTimer) {
+ clearTimeout(persistTimer);
+ persistTimer = null;
+ }
+ await saveTabs(tabs.value, activeTabId.value, { groups: groups.value, focusedGroupId: focusedGroupId.value, orientation: orientation.value, sizes: sizes.value });
+ const payload = await api.loadOpenTabsState();
+ const savedTab = payload?.tabs?.find((item: unknown) => !!item && typeof item === "object" && (item as { id?: unknown }).id === tabId) as { typeManagementDraft?: unknown } | undefined;
+ const saved = restoreOracleTypeManagementDraft(savedTab?.typeManagementDraft);
+ if (
+ isDetachedWindow() ||
+ storePersistGeneration !== persistGeneration ||
+ !tabs.value.includes(tab) ||
+ tab.typeManagementDraft?.planId !== record.planId ||
+ tab.typeManagementDraft.revision !== record.revision ||
+ !saved ||
+ saved.planId !== record.planId ||
+ saved.revision !== record.revision ||
+ saved.target.connectionId !== record.target.connectionId ||
+ saved.target.database !== record.target.database ||
+ saved.target.owner !== record.target.owner ||
+ saved.target.name !== record.target.name ||
+ saved.operation !== record.operation ||
+ !typeManagementRecordsEqual(savedTab?.typeManagementDraft, record)
+ )
+ throw new Error("The TYPE recovery revision could not be confirmed in app_state. No further SQL may be sent.");
+ }
+
async function prepareDetachedTab(tabId: string, runtime: DetachedTabRuntimeState = {}): Promise<DetachedTabHandoff> {
const tab = tabs.value.find((candidate) => candidate.id === tabId);
if (!tab) throw new Error("Tab is no longer open");
+ if (tab.typeManagementDraft?.state !== undefined && tab.typeManagementDraft.state !== "complete") throw new Error("Keep the unfinished TYPE change in the main workspace for durable recovery.");
if (tab.mode !== "query" && tab.mode !== "data") throw new Error("Only SQL and data tabs can be detached");
if (tab.isExecuting || tab.isCancelling || tab.isExplaining) throw new Error("Wait for the current operation to finish before detaching this tab");
@@ -3277,7 +3328,7 @@ export const useQueryStore = defineStore("query", () => {
assertSourceIdentity(identity);
if (current?.objectSource !== objectSource || resolvedType !== objectSource.objectType) return;
if (current.connectionId !== connectionId || current.database !== database || (current.objectSource.schema || current.schema || current.database) !== schema) return;
- if (raw.editable === false || (OBJECT_SOURCE_READ_ONLY_TYPES.includes(resolvedType) && !(databaseType === "oceanbase-oracle" && resolvedType === "SEQUENCE"))) return;
+ if (raw.editable === false || (OBJECT_SOURCE_READ_ONLY_TYPES.includes(resolvedType) && !(databaseType === "oceanbase-oracle" && resolvedType === "SEQUENCE") && !isOracleFamilyTypeSource(databaseType, resolvedType))) return;
if (isTabDirty(current)) return;
updateSql(id, editableSource);
markTabClean(current);
@@ -3309,7 +3360,7 @@ export const useQueryStore = defineStore("query", () => {
sourceRevalidateInFlight.delete(id);
tab.sourceLoad = {
startedAt: Date.now(),
- initialEditing: tab.sourceLoad?.initialEditing ?? !!tab.objectSource,
+ initialEditing: tab.sourceLoad?.initialEditing ?? tab.typeSourceEditing ?? !!tab.objectSource,
request,
};
void loadObjectSourceIntoTab(id);
@@ -3384,7 +3435,9 @@ export const useQueryStore = defineStore("query", () => {
const tab = tabs.value.find((candidate) => candidate.id === id);
if (!tab?.sourceLoad) return;
const details = sourceDetails(loaded, { ...loaded.request, objectType: loaded.resolvedType }, tab.objectDetails?.section);
- const sourceIsEditable = !isViewOnlySourceWithoutEditablePayload(loaded.initialEditing, loaded.resolvedType) && loaded.raw.editable !== false && (!OBJECT_SOURCE_READ_ONLY_TYPES.includes(loaded.resolvedType) || (loaded.databaseType === "oceanbase-oracle" && loaded.resolvedType === "SEQUENCE"));
+ const managedType = isOracleFamilyTypeSource(loaded.databaseType, loaded.resolvedType);
+ const sourceIsEditable =
+ !isViewOnlySourceWithoutEditablePayload(loaded.initialEditing, loaded.resolvedType) && loaded.raw.editable !== false && (!OBJECT_SOURCE_READ_ONLY_TYPES.includes(loaded.resolvedType) || (loaded.databaseType === "oceanbase-oracle" && loaded.resolvedType === "SEQUENCE") || managedType);
if (sourceIsEditable) {
const options: OpenObjectSourceTabOptions = {
connectionId: loaded.connectionId,
@@ -3397,13 +3450,15 @@ export const useQueryStore = defineStore("query", () => {
};
// 解析后的身份可能命中已存在的 tab(例:先按 FUNCTION 打开过,这次请求的是 PROCEDURE)。
// 有则交接给它并关掉 pending 占位,避免同一个对象出现两个 tab。
- const existing = findMatchingObjectSourceTab(options, id);
+ // 已有源码页签的显式刷新原地完成,不向另一个旧身份交接或丢失本页的恢复记录。
+ const existing = tab.objectSource ? undefined : findMatchingObjectSourceTab(options, id);
if (existing) {
const snapshot = getObjectSourceIdentitySnapshot(existing);
if (snapshot) assertSourceIdentity(snapshot);
clearObjectSourceLoad(tab);
closeTab(id);
existing.sourceView = true;
+ if (managedType && loaded.initialEditing === true) existing.typeSourceEditing = true;
existing.objectDetails = details;
switchTab(existing.id);
if (!isTabDirty(existing)) {
@@ -3414,6 +3469,7 @@ export const useQueryStore = defineStore("query", () => {
}
updateSql(id, loaded.editableSource);
setObjectSource(id, options.objectSource);
+ if (managedType) tab.typeSourceEditing = loaded.initialEditing === true;
} else {
updateSql(id, loaded.raw.source);
}
@@ -4528,6 +4584,7 @@ export const useQueryStore = defineStore("query", () => {
});
function isTabDirty(tab: QueryTab): boolean {
+ if (tab.typeManagementDraft && tab.typeManagementDraft.state !== "complete") return true;
if (tab.mode === "structure") {
// Legacy persisted structure drafts predate the dirty flag; treat them as dirty until the editor rehydrates them.
return !!tab.structureDraft && tab.structureDraft.dirty !== false;
@@ -4542,9 +4599,12 @@ export const useQueryStore = defineStore("query", () => {
const hasDirtyTabs = computed(() => tabs.value.some((tab) => isTabDirty(tab)));
const shouldConfirmUnsavedSqlClose = computed(() => useSettingsStore().editorSettings.confirmUnsavedSqlClose);
const keepUnsavedTabsDraftsOnAppClose = computed(() => useSettingsStore().editorSettings.appCloseUnsavedTabsMode === "keep-drafts");
- const requiresAppCloseDraftPersist = computed(() => tabs.value.some((tab) => tab.isDefaultQuery) || (shouldConfirmUnsavedSqlClose.value && keepUnsavedTabsDraftsOnAppClose.value && tabs.value.some((tab) => tab.mode === "query" && isTabDirty(tab))));
+ const requiresAppCloseDraftPersist = computed(
+ () => tabs.value.some((tab) => tab.isDefaultQuery || (tab.typeManagementDraft && tab.typeManagementDraft.state !== "complete")) || (shouldConfirmUnsavedSqlClose.value && keepUnsavedTabsDraftsOnAppClose.value && tabs.value.some((tab) => tab.mode === "query" && isTabDirty(tab))),
+ );
function shouldConfirmTabOnAppClose(tab: QueryTab): boolean {
+ if (tab.typeManagementDraft && tab.typeManagementDraft.state !== "complete") return false;
if (tab.isDefaultQuery) return false;
if (!shouldConfirmTabClose(tab)) return false;
return !keepUnsavedTabsDraftsOnAppClose.value || tab.mode !== "query";
@@ -4896,6 +4956,10 @@ export const useQueryStore = defineStore("query", () => {
function closeTab(id: string, { force = false, skipHistory = false }: { force?: boolean; skipHistory?: boolean } = {}) {
const tab = tabs.value.find((t) => t.id === id);
if (!tab) return;
+ if (tab.typeManagementDraft?.state === "running") {
+ useToast().toast(t("objects.typeManagementRunningClose"), 5000);
+ return;
+ }
if (needsDefaultQuerySave(tab) || (tab.isDefaultQuery && defaultQuerySaves.has(id))) {
void flushDefaultQuery(tab)
.then(() => closeTab(id, { force, skipHistory }))
@@ -4962,6 +5026,7 @@ export const useQueryStore = defineStore("query", () => {
}
function shouldConfirmTabClose(tab: QueryTab): boolean {
+ if (tab.typeManagementDraft && tab.typeManagementDraft.state !== "complete") return true;
if (tab.isDefaultQuery) return false;
if (tab.mode === "structure") return isTabDirty(tab);
return shouldConfirmUnsavedSqlClose.value && isTabDirty(tab);
@@ -7820,6 +7885,7 @@ export const useQueryStore = defineStore("query", () => {
assertUpdateAllowsInteraction();
const tab = findExecutionTab(id);
if (!tab || !sql.trim()) return;
+ if (tab.typeManagementDraft || isOracleFamilyTypeSource(effectiveDatabaseTypeForConnection(useConnectionStore().getConfig(tab.connectionId)), tab.objectSource?.objectType)) throw new Error(t("objects.typeManagementUseSave"));
if (pendingResultRunPreparations.has(tab)) return false;
const openInNewResultTab = tab.mode === "query" && options?.openInNewResultTab === true;
@@ -10989,6 +11055,7 @@ export const useQueryStore = defineStore("query", () => {
forceCloseAllPendingTabs,
cancelClosePendingTab,
flushPendingPersist,
+ persistTypeManagementDraft,
saveAndClosePendingTab,
suspendCloseConfirm,
resumeCloseConfirm,
diff --git a/apps/desktop/src/types/database.ts b/apps/desktop/src/types/database.ts
index 33fad22630..4d7c8fcf75 100644
--- a/apps/desktop/src/types/database.ts
+++ b/apps/desktop/src/types/database.ts
@@ -1175,7 +1175,7 @@ export interface MysqlEventInfo {
source?: string | null;
}
-export type CustomTypeKind = "base" | "composite" | "domain" | "enum" | "range" | "multirange";
+export type CustomTypeKind = "base" | "composite" | "domain" | "enum" | "range" | "multirange" | "object" | "collection" | "other";
export interface CustomTypeMember {
name: string;
@@ -1220,6 +1220,75 @@ export interface CustomTypeDdl {
warnings?: string[];
}
+export interface TypeMetadataRead {
+ state: "available" | "incomplete" | "unavailable" | "unsupported";
+ reason?: string | null;
+}
+
+export interface OracleTypeAttribute {
+ name: string;
+ ordinal?: number | null;
+ typeOwner?: string | null;
+ typeName?: string | null;
+ typeModifier?: string | null;
+ length?: number | null;
+ precision?: number | null;
+ scale?: number | null;
+}
+
+export interface OracleTypeMethodParameter {
+ name?: string | null;
+ ordinal?: number | null;
+ mode?: string | null;
+ typeOwner?: string | null;
+ typeName?: string | null;
+ typeModifier?: string | null;
+}
+
+export interface OracleTypeMethod {
+ name: string;
+ number?: number | null;
+ kind?: string | null;
+ parameterCount?: number | null;
+ resultCount?: number | null;
+ parameters: OracleTypeMethodParameter[];
+ results: OracleTypeMethodParameter[];
+ parametersRead: TypeMetadataRead;
+ resultsRead: TypeMetadataRead;
+}
+
+export interface OracleTypeCollection {
+ kind?: string | null;
+ upperBound?: number | null;
+ elementOwner?: string | null;
+ elementName?: string | null;
+ elementModifier?: string | null;
+ length?: number | null;
+ precision?: number | null;
+ scale?: number | null;
+}
+
+export interface OracleTypeMetadata {
+ status?: string | null;
+ typeCode?: string | null;
+ isFinal?: boolean | null;
+ instantiable?: boolean | null;
+ supertypeOwner?: string | null;
+ supertypeName?: string | null;
+ attributeCount?: number | null;
+ methodCount?: number | null;
+ bodyVisible?: boolean | null;
+ bodyStatus?: string | null;
+ propertiesRead: TypeMetadataRead;
+ bodyRead: TypeMetadataRead;
+ attributesRead: TypeMetadataRead;
+ methodsRead: TypeMetadataRead;
+ collectionRead: TypeMetadataRead;
+ attributes: OracleTypeAttribute[];
+ methods: OracleTypeMethod[];
+ collection?: OracleTypeCollection | null;
+}
+
export interface CustomTypeDetails {
name: string;
schema: string;
@@ -1228,6 +1297,203 @@ export interface CustomTypeDetails {
members: CustomTypeMember[];
properties: CustomTypeProperties;
ddl?: CustomTypeDdl | null;
+ oracleMetadata?: OracleTypeMetadata | null;
+}
+
+export interface TypeRecoveryContext {
+ planId: string;
+ stepId: string;
+}
+
+export interface TypeExecutionBinding extends TypeRecoveryContext {
+ executionId: string;
+ connectionId: string;
+ database: string;
+ schema: string | null;
+ sql: string;
+}
+
+export interface OracleTypeManagementTarget {
+ connectionId: string;
+ database: string;
+ owner: string;
+ name: string;
+}
+
+export interface OracleTypeManagementObjectKey {
+ owner: string;
+ name: string;
+ objectType: string;
+}
+
+export interface OracleTypeDataRelationKey {
+ owner: string;
+ name: string;
+}
+export interface OracleTypeDataField {
+ sourcePath: string[];
+ objectNull: boolean;
+ oldColumn: string;
+ expectedColumn: string;
+ targetPath: string[];
+ targetObjectNull?: boolean;
+ unchanged: boolean;
+}
+export interface OracleTypeDataMappingInput {
+ id: string;
+ source: OracleTypeDataRelationKey;
+ old: OracleTypeDataRelationKey;
+ expected: OracleTypeDataRelationKey;
+ target: OracleTypeDataRelationKey;
+ fields: OracleTypeDataField[];
+}
+export interface OracleTypeDataProjection {
+ path: string[];
+ objectNull: boolean;
+ dataType: string;
+}
+export interface OracleTypeDataRelation {
+ relation: OracleTypeDataRelationKey;
+ objectId: string;
+ readOnly: boolean | null;
+ structure: string;
+ projection: OracleTypeDataProjection[];
+}
+export interface OracleTypeDataBaseline {
+ relation: OracleTypeDataRelation;
+ rowCount: number;
+ fingerprint: string;
+}
+export interface OracleTypeDataManifest {
+ mapping: OracleTypeDataMappingInput;
+ original: OracleTypeDataBaseline;
+ old: OracleTypeDataBaseline;
+ expected: OracleTypeDataBaseline;
+ preparedTarget?: OracleTypeDataBaseline | null;
+ verifiedTarget?: OracleTypeDataBaseline | null;
+}
+export interface OracleTypeDataRequest {
+ target: OracleTypeManagementTarget;
+ action: "describe" | "register" | "verify" | "validate_insert";
+ relation?: OracleTypeDataRelationKey;
+ mapping?: OracleTypeDataMappingInput;
+ manifest?: OracleTypeDataManifest;
+ sql?: string;
+}
+export interface OracleTypeDataResult {
+ relation?: OracleTypeDataRelation | null;
+ manifest?: OracleTypeDataManifest | null;
+ insertSql?: string | null;
+}
+
+/** Database-native evolution keeps data in place. These guards contain no row values. */
+export interface OracleTypeEvolutionManifest {
+ target: OracleTypeManagementTarget;
+ sourceBefore: string;
+ sourceAfter: string;
+ statements: string[];
+ metadata: string;
+ phase: number;
+}
+export interface OracleTypeEvolutionRequest {
+ target: OracleTypeManagementTarget;
+ sourceBefore: string;
+ sourceAfter: string;
+ manifest?: OracleTypeEvolutionManifest;
+}
+
+export interface OracleTypeManagementPrivilege {
+ grantee: string;
+ privilege: string;
+ grantable?: boolean | null;
+ hierarchy?: boolean | null;
+ grantor?: string | null;
+ privilegeId?: string | null;
+ privilegeType?: string | null;
+ columnId?: string | null;
+}
+
+export interface OracleTypeManagementObject {
+ owner: string;
+ name: string;
+ objectType: string;
+ exists?: boolean | null;
+ objectId?: string | null;
+ status?: string | null;
+ statusRead: TypeMetadataRead;
+ triggerEnabled?: boolean | null;
+ triggerEnabledRead?: TypeMetadataRead | null;
+ source?: string | null;
+ sourceRead: TypeMetadataRead;
+ sourceFingerprint?: string | null;
+ errors: OracleTypeManagementError[];
+ errorsRead: TypeMetadataRead;
+ directPrivileges: OracleTypeManagementPrivilege[];
+ privilegesRead: TypeMetadataRead;
+}
+
+export interface OracleTypeManagementError {
+ line: number;
+ position: number;
+ text: string;
+}
+
+export interface OracleTypeManagementDependency {
+ owner: string;
+ name: string;
+ objectType: string;
+ referencedOwner: string;
+ referencedName: string;
+ referencedType: string;
+ referencedLink?: string | null;
+}
+
+export interface OracleTypeManagementReference {
+ owner: string;
+ tableName: string;
+ columnName?: string | null;
+ dataTypeOwner?: string | null;
+ dataType?: string | null;
+ tableStatus?: string | null;
+ tableReadOnly?: boolean | null;
+}
+
+export interface OracleTypeManagementSnapshot {
+ target: OracleTypeManagementTarget;
+ visibilityScope: string;
+ actingUser?: string | null;
+ actingUserRead: TypeMetadataRead;
+ details?: CustomTypeDetails | null;
+ detailsRead: TypeMetadataRead;
+ typeSource?: string | null;
+ typeSourceRead: TypeMetadataRead;
+ bodySource?: string | null;
+ bodySourceRead: TypeMetadataRead;
+ objects: OracleTypeManagementObject[];
+ dependencies: OracleTypeManagementDependency[];
+ dependenciesRead: TypeMetadataRead;
+ persistentReferences: OracleTypeManagementReference[];
+ persistentReferencesRead: TypeMetadataRead;
+ directPrivileges: OracleTypeManagementPrivilege[];
+ privilegesRead: TypeMetadataRead;
+}
+
+export type OracleTypeManagementSqlOperation = "save_spec" | "save_body" | "drop_spec" | "drop_body" | "grant_execute" | "grant_privilege" | "rebuild_source" | "compile_spec" | "compile_trigger";
+export interface OracleTypeManagementSqlInput {
+ databaseType: DatabaseType;
+ operation: OracleTypeManagementSqlOperation;
+ owner: string;
+ name: string;
+ source?: string | null;
+ grantee?: string | null;
+ grantable?: boolean;
+ objectType?: ObjectSourceKind;
+ privilege?: string;
+ triggerEnabled?: boolean;
+}
+export interface OracleTypeManagementSqlResult {
+ statements: string[];
+ sourceFingerprint?: string | null;
}
export interface ColumnInfo {
@@ -2492,6 +2758,10 @@ export interface QueryTab {
objectType: ObjectSourceKind;
signature?: string;
};
+ /** Durable TYPE definitions and step records; restored plans require fresh verification. */
+ typeManagementDraft?: import("@/lib/table/oracleTypeManagement").OracleTypeManagementDraft;
+ /** Explicit edit mode; TYPE source opens read-only and restores read-only. */
+ typeSourceEditing?: boolean;
/**
* 「先出 UI 再加载」的中间态:源码 tab 已经可见,但源码还在路上
* (ensureConnected + getObjectSource)。让 tab 栏与编辑区在等待期间就有反馈,
diff --git a/crates/dbx-core/src/persistence/storage.rs b/crates/dbx-core/src/persistence/storage.rs
index 1c78b79e36..9ce30eddc9 100644
--- a/crates/dbx-core/src/persistence/storage.rs
+++ b/crates/dbx-core/src/persistence/storage.rs
@@ -3,6 +3,9 @@ pub use dbx_drivers::runtime_config::{
DUCKDB_WORKER_MAX_PROCESSES_MIN,
};
+mod type_execution_receipts;
+pub use type_execution_receipts::{TypeExecutionBinding, TypeRecoveryContext};
+
use std::collections::{HashMap, HashSet};
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex, OnceLock};
@@ -13932,6 +13935,70 @@ mod tests {
assert_eq!(storage.load_app_settings_json().await.unwrap().get("ai_chat_selection_v1"), None);
}
+ #[tokio::test]
+ async fn type_management_recovery_manifest_survives_sqlite_storage_reopen() {
+ let dir = tempfile::tempdir().unwrap();
+ let path = dir.path().join("dbx.db");
+ let storage = crate::persistence::test_storage::open(&path).await.unwrap();
+ let key = |name: &str| crate::db::OracleTypeDataRelationKey { owner: "Mixed Owner".into(), name: name.into() };
+ let baseline = |name: &str, row_count, read_only| crate::db::OracleTypeDataBaseline {
+ relation: crate::db::OracleTypeDataRelation {
+ relation: key(name),
+ object_id: "9007199254740993".into(),
+ read_only: Some(read_only),
+ structure: format!("{name}-definition"),
+ projection: vec![crate::db::OracleTypeDataProjection {
+ path: vec!["ID".into()],
+ object_null: false,
+ data_type: "NUMBER(38,0)".into(),
+ }],
+ },
+ row_count,
+ fingerprint: "d".repeat(64),
+ };
+ let manifest = crate::db::OracleTypeDataManifest {
+ mapping: crate::db::OracleTypeDataMappingInput {
+ id: "same-original-baseline".into(),
+ source: key("SRC"),
+ old: key("OLD"),
+ expected: key("EXPECTED"),
+ target: key("RESULT"),
+ fields: vec![crate::db::OracleTypeDataField {
+ source_path: vec!["ID".into()],
+ object_null: false,
+ old_column: "ID".into(),
+ expected_column: "ID".into(),
+ target_path: vec!["ID".into()],
+ target_object_null: false,
+ unchanged: true,
+ }],
+ },
+ original: baseline("SRC", 3, false),
+ old: baseline("OLD", 3, true),
+ expected: baseline("EXPECTED", 3, true),
+ prepared_target: Some(baseline("RESULT", 0, false)),
+ verified_target: None,
+ };
+ let state = serde_json::json!({
+ "tabs": [{
+ "id": "source-type", "title": "TYPE", "connectionId": "fixture", "database": "APP", "sql": "TYPE draft",
+ "typeManagementDraft": {
+ "version": 1, "planId": "type-recovery-1", "revision": 9,
+ "target": {"connectionId": "fixture", "database": "APP", "owner": "Mixed Owner", "name": "Type' Name", "databaseType": "oracle"},
+ "operation": "save-spec", "requiresReverify": true, "state": "stopped",
+ "drafts": [{"owner": "Mixed Owner", "name": "Type' Name", "objectType": "TYPE BODY", "source": "TYPE BODY draft"}],
+ "steps": [{"id": "root", "state": "confirmed"}, {"id": "body", "state": "unknown"}],
+ "dataMappings": [{"manifest": manifest, "insertSql": "bounded INSERT preview", "insertDraft": "bounded INSERT preview", "insertState": "unknown"}]
+ }
+ }], "activeTabId": "source-type"
+ });
+ storage.save_open_tabs_state(&state).await.unwrap();
+ assert_eq!(storage.load_open_tabs_state().await.unwrap(), Some(state.clone()));
+ drop(storage);
+ let reopened = crate::persistence::test_storage::open(&path).await.unwrap();
+ assert_eq!(reopened.load_open_tabs_state().await.unwrap(), Some(state));
+ }
+
// Selection JSON written before per-db-type prompt template defaults existed
// must still deserialize; the new maps fall back to empty.
#[tokio::test]
diff --git a/crates/dbx-core/src/persistence/storage/type_execution_receipts.rs b/crates/dbx-core/src/persistence/storage/type_execution_receipts.rs
new file mode 100644
index 0000000000..b8a63a2c24
--- /dev/null
+++ b/crates/dbx-core/src/persistence/storage/type_execution_receipts.rs
@@ -0,0 +1,251 @@
+use super::{params, Deserialize, OptionalExtension, Serialize, Storage};
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TypeRecoveryContext {
+ pub plan_id: String,
+ pub step_id: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TypeExecutionBinding {
+ pub execution_id: String,
+ #[serde(flatten)]
+ pub context: TypeRecoveryContext,
+ pub connection_id: String,
+ pub database: String,
+ pub schema: Option<String>,
+ pub sql: String,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct Receipt {
+ binding: TypeExecutionBinding,
+ database_terminal: bool,
+}
+
+fn key(execution_id: &str) -> String {
+ format!("type_execution_receipt:{execution_id}")
+}
+
+impl Storage {
+ pub async fn claim_type_execution(&self, binding: &TypeExecutionBinding) -> Result<(), String> {
+ if [&binding.execution_id, &binding.context.plan_id, &binding.context.step_id, &binding.connection_id]
+ .iter()
+ .any(|value| value.trim().is_empty())
+ {
+ return Err("TYPE recovery binding is incomplete; execution outcome is unknown".into());
+ }
+ let key = key(&binding.execution_id);
+ let value = serde_json::to_string(&Receipt { binding: binding.clone(), database_terminal: false })
+ .map_err(|error| error.to_string())?;
+ self.with_conn(move |conn| {
+ let inserted = conn
+ .execute("INSERT OR IGNORE INTO app_state (key, value_json) VALUES (?1, ?2)", params![key, value])
+ .map_err(|error| error.to_string())?;
+ if inserted != 1 {
+ return Err(
+ "TYPE execution ID already has a recovery record; inspect the original outcome, do not replay"
+ .into(),
+ );
+ }
+ Ok(())
+ })
+ .await
+ }
+
+ pub async fn type_execution_terminal(&self, binding: &TypeExecutionBinding) -> Result<Option<bool>, String> {
+ let key = key(&binding.execution_id);
+ let json: Option<String> = self
+ .with_conn(move |conn| {
+ conn.query_row("SELECT value_json FROM app_state WHERE key = ?1", [key], |row| row.get(0))
+ .optional()
+ .map_err(|error| error.to_string())
+ })
+ .await?;
+ let Some(json) = json else { return Ok(None) };
+ let receipt: Receipt = serde_json::from_str(&json).map_err(|error| error.to_string())?;
+ if receipt.binding != *binding {
+ return Err("TYPE execution recovery binding does not match the original request".into());
+ }
+ Ok(Some(receipt.database_terminal))
+ }
+
+ pub async fn finish_type_execution(&self, binding: &TypeExecutionBinding) -> Result<(), String> {
+ let key = key(&binding.execution_id);
+ let pending = serde_json::to_string(&Receipt { binding: binding.clone(), database_terminal: false })
+ .map_err(|error| error.to_string())?;
+ let terminal = serde_json::to_string(&Receipt { binding: binding.clone(), database_terminal: true })
+ .map_err(|error| error.to_string())?;
+ self.with_conn(move |conn| {
+ let updated = conn
+ .execute(
+ "UPDATE app_state SET value_json = ?1 WHERE key = ?2 AND value_json = ?3",
+ params![terminal, key, pending],
+ )
+ .map_err(|error| error.to_string())?;
+ if updated != 1 {
+ return Err("TYPE terminal receipt could not be saved for the original request; do not replay".into());
+ }
+ Ok(())
+ })
+ .await
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn binding() -> TypeExecutionBinding {
+ TypeExecutionBinding {
+ execution_id: "execution".into(),
+ context: TypeRecoveryContext { plan_id: "plan".into(), step_id: "step".into() },
+ connection_id: "connection".into(),
+ database: "service".into(),
+ schema: Some("APP".into()),
+ sql: "CREATE OR REPLACE TYPE APP.T AS OBJECT (ID NUMBER)".into(),
+ }
+ }
+
+ async fn storage() -> (Storage, std::path::PathBuf) {
+ let path = std::env::temp_dir().join(format!("dbx-type-receipt-{}.db", uuid::Uuid::new_v4()));
+ (crate::persistence::test_storage::open(&path).await.unwrap(), path)
+ }
+
+ #[tokio::test]
+ async fn terminal_receipt_survives_reopen_and_does_not_allow_reclaim() {
+ let (storage, path) = storage().await;
+ let binding = binding();
+ storage.claim_type_execution(&binding).await.unwrap();
+ assert_eq!(storage.type_execution_terminal(&binding).await.unwrap(), Some(false));
+ storage.finish_type_execution(&binding).await.unwrap();
+ drop(storage);
+ let reopened = crate::persistence::test_storage::open(&path).await.unwrap();
+ assert_eq!(reopened.type_execution_terminal(&binding).await.unwrap(), Some(true));
+ assert!(reopened.claim_type_execution(&binding).await.is_err());
+ }
+
+ #[tokio::test]
+ async fn concurrent_claim_has_one_winner_and_every_binding_field_is_checked() {
+ let (storage, _) = storage().await;
+ let binding = binding();
+ let (first, second) =
+ tokio::join!(storage.claim_type_execution(&binding), storage.claim_type_execution(&binding));
+ assert_ne!(first.is_ok(), second.is_ok());
+ for field in ["planId", "stepId", "connectionId", "database", "schema", "sql"] {
+ let mut changed = serde_json::to_value(&binding).unwrap();
+ changed[field] = serde_json::json!("other");
+ let changed = serde_json::from_value(changed).unwrap();
+ assert!(storage.type_execution_terminal(&changed).await.is_err(), "{field}");
+ assert!(storage.finish_type_execution(&changed).await.is_err(), "{field}");
+ }
+ let mut missing = binding.clone();
+ missing.execution_id = "missing".into();
+ assert_eq!(storage.type_execution_terminal(&missing).await.unwrap(), None);
+ assert_eq!(storage.type_execution_terminal(&binding).await.unwrap(), Some(false));
+ }
+
+ #[tokio::test]
+ async fn failed_terminal_write_preserves_pending_receipt() {
+ let (storage, _) = storage().await;
+ let binding = binding();
+ storage.claim_type_execution(&binding).await.unwrap();
+ storage.with_conn(|conn| {
+ conn.execute_batch("CREATE TRIGGER reject_receipt_update BEFORE UPDATE ON app_state BEGIN SELECT RAISE(ABORT, 'receipt write failed'); END;")
+ .map_err(|error| error.to_string())
+ }).await.unwrap();
+ let running = crate::query_cancel::RunningQueries::default();
+ let registered =
+ running.register_task_for_terminal_confirmation(binding.execution_id.clone(), Default::default());
+ let error = crate::query_cancel::finish_conditional_update(registered, &storage, Some(&binding), Ok(()))
+ .await
+ .unwrap_err();
+ let envelope = serde_json::to_value(error).unwrap();
+ assert_eq!(envelope["operationOutcome"], "unknown");
+ assert_eq!(envelope["code"], "DBX-LEGACY-0001");
+ assert_eq!(storage.type_execution_terminal(&binding).await.unwrap(), Some(false));
+ }
+
+ #[tokio::test]
+ async fn observation_requires_durable_binding_even_when_memory_reports_completion() {
+ use crate::query_cancel::{observe_type_execution, RunningQueries};
+ let (storage, path) = storage().await;
+ let binding = binding();
+ let running = RunningQueries::default();
+ let registered =
+ running.register_task_for_terminal_confirmation(binding.execution_id.clone(), Default::default());
+ assert!(registered.finish_with_database_result(&Ok::<_, crate::query::QueryExecutionError>(())));
+ let observe = || observe_type_execution(&storage, &running, &binding, std::time::Duration::ZERO);
+ assert!(!observe().await.unwrap().terminal);
+ storage.claim_type_execution(&binding).await.unwrap();
+ assert!(!observe().await.unwrap().terminal);
+ storage.finish_type_execution(&binding).await.unwrap();
+ let mut wrong = binding.clone();
+ wrong.sql.push(';');
+ assert!(observe_type_execution(&storage, &running, &wrong, std::time::Duration::ZERO).await.is_err());
+ drop(storage);
+ let reopened = crate::persistence::test_storage::open(&path).await.unwrap();
+ let result = observe_type_execution(&reopened, &RunningQueries::default(), &binding, std::time::Duration::ZERO)
+ .await
+ .unwrap();
+ assert!(result.terminal && result.database_terminal == Some(true));
+ }
+
+ #[tokio::test]
+ async fn failed_claim_does_not_create_a_receipt() {
+ let (storage, _) = storage().await;
+ storage.with_conn(|conn| {
+ conn.execute_batch("CREATE TRIGGER reject_receipt_insert BEFORE INSERT ON app_state BEGIN SELECT RAISE(ABORT, 'receipt claim failed'); END;")
+ .map_err(|error| error.to_string())
+ }).await.unwrap();
+ assert!(storage.claim_type_execution(&binding()).await.is_err());
+ assert_eq!(storage.type_execution_terminal(&binding()).await.unwrap(), None);
+ }
+
+ #[tokio::test]
+ async fn completion_persists_only_database_terminal_results_before_reply() {
+ use crate::db::agent_driver::{AgentErrorStage, AgentOperationOutcome};
+ use crate::query::QueryExecutionError;
+ use crate::query_cancel::{finish_conditional_update, RunningQueries};
+ let (storage, _) = storage().await;
+ let running = RunningQueries::default();
+ for (index, (result, terminal)) in [
+ (Ok(()), true),
+ (Err(QueryExecutionError::Timeout("timeout".into())), false),
+ (Err(QueryExecutionError::Sql("legacy transport failure".into())), false),
+ (
+ Err(QueryExecutionError::Canceled {
+ stage: AgentErrorStage::Execute,
+ operation_outcome: AgentOperationOutcome::Unknown,
+ }),
+ false,
+ ),
+ (
+ Err(QueryExecutionError::Canceled {
+ stage: AgentErrorStage::Execute,
+ operation_outcome: AgentOperationOutcome::NotStarted,
+ }),
+ true,
+ ),
+ ]
+ .into_iter()
+ .enumerate()
+ {
+ let mut binding = binding();
+ binding.execution_id = format!("case-{index}");
+ storage.claim_type_execution(&binding).await.unwrap();
+ let registered =
+ running.register_task_for_terminal_confirmation(binding.execution_id.clone(), Default::default());
+ let reply = finish_conditional_update(registered, &storage, Some(&binding), result).await;
+ if !terminal {
+ let envelope = serde_json::to_value(reply.unwrap_err()).unwrap();
+ assert_eq!(envelope["operationOutcome"], "unknown");
+ assert_eq!(envelope["code"], "DBX-LEGACY-0001");
+ }
+ assert_eq!(storage.type_execution_terminal(&binding).await.unwrap(), Some(terminal));
+ }
+ }
+}
diff --git a/crates/dbx-core/src/query/query_cancel.rs b/crates/dbx-core/src/query/query_cancel.rs
index cdf6003a7d..57806588ef 100644
--- a/crates/dbx-core/src/query/query_cancel.rs
+++ b/crates/dbx-core/src/query/query_cancel.rs
@@ -78,6 +78,51 @@ struct RunningTask {
pub struct CancellationWaitResult {
pub requested: bool,
pub terminal: bool,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub database_terminal: Option<bool>,
+}
+
+pub async fn observe_type_execution(
+ storage: &crate::storage::Storage,
+ running: &RunningQueries,
+ binding: &crate::storage::TypeExecutionBinding,
+ timeout: Duration,
+) -> Result<CancellationWaitResult, String> {
+ let mut terminal = storage.type_execution_terminal(binding).await?;
+ if terminal == Some(false) {
+ // The in-memory ID can be reused by ordinary callers; only the bound
+ // durable receipt can prove this TYPE statement reached a terminal state.
+ running.wait_for_completion(&binding.execution_id, timeout).await;
+ terminal = storage.type_execution_terminal(binding).await?;
+ }
+ Ok(CancellationWaitResult {
+ requested: false,
+ terminal: terminal == Some(true),
+ database_terminal: Some(terminal == Some(true)),
+ })
+}
+
+pub async fn finish_conditional_update<T>(
+ registered: RegisteredQuery,
+ storage: &crate::storage::Storage,
+ binding: Option<&crate::storage::TypeExecutionBinding>,
+ result: Result<T, crate::query::QueryExecutionError>,
+) -> Result<T, crate::backend_error::BackendError> {
+ let terminal = registered.finish_with_database_result(&result);
+ if let Some(binding) = binding {
+ if terminal {
+ storage.finish_type_execution(binding).await.map_err(|error| {
+ crate::backend_error::BackendError::from_legacy_backend(&format!(
+ "TYPE terminal receipt was not saved: {error}. Keep the recovery plan; do not replay."
+ ))
+ })?;
+ } else {
+ // Legacy SQL envelopes can look like acknowledged SQL rejections to
+ // the frontend. An unproven TYPE result must remain unknown there too.
+ return result.map_err(|error| crate::backend_error::BackendError::from_legacy_backend(&error.to_string()));
+ }
+ }
+ result.map_err(crate::query::QueryExecutionError::into_backend_error)
}
#[derive(Clone, Default)]
@@ -90,7 +135,7 @@ pub struct RunningQueries {
// before its interrupt handle was ready — inserted a closure keyed to
// an execution id nothing would ever look at again, leaking it forever.
inner: Arc<Mutex<HashMap<String, RunningTask>>>,
- completed: Arc<Mutex<HashMap<String, std::time::Instant>>>,
+ completed: Arc<Mutex<HashMap<String, (std::time::Instant, bool)>>>,
next_registration_id: Arc<AtomicU64>,
}
@@ -145,7 +190,7 @@ impl RunningQueries {
let previous = {
let mut inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
let mut completed = self.completed.lock().unwrap_or_else(|e| e.into_inner());
- completed.retain(|_, completed_at| completed_at.elapsed() < DETACHED_REGISTRATION_GRACE_PERIOD);
+ completed.retain(|_, (completed_at, _)| completed_at.elapsed() < DETACHED_REGISTRATION_GRACE_PERIOD);
completed.remove(&execution_id);
inner.insert(
execution_id.clone(),
@@ -168,17 +213,47 @@ impl RunningQueries {
}
}
- RegisteredQuery { execution_id, registration_id, token, running_queries: self.clone(), detached: false }
+ RegisteredQuery {
+ execution_id,
+ registration_id,
+ token,
+ running_queries: self.clone(),
+ detached: false,
+ database_terminal: false,
+ }
}
- fn completed_execution_is_terminal(&self, execution_id: &str) -> bool {
+ fn completed_execution_result(&self, execution_id: &str) -> CancellationWaitResult {
let inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
if inner.contains_key(execution_id) {
- return false;
+ return CancellationWaitResult { requested: false, terminal: false, database_terminal: Some(false) };
}
let mut completed = self.completed.lock().unwrap_or_else(|e| e.into_inner());
- completed.retain(|_, completed_at| completed_at.elapsed() < DETACHED_REGISTRATION_GRACE_PERIOD);
- completed.contains_key(execution_id)
+ completed.retain(|_, (completed_at, _)| completed_at.elapsed() < DETACHED_REGISTRATION_GRACE_PERIOD);
+ CancellationWaitResult {
+ requested: false,
+ terminal: completed.contains_key(execution_id),
+ database_terminal: Some(completed.get(execution_id).is_some_and(|(_, proven)| *proven)),
+ }
+ }
+
+ /// Wait without cancelling. Missing or expired registrations prove nothing.
+ pub async fn wait_for_completion(&self, execution_id: &str, timeout: Duration) -> CancellationWaitResult {
+ let completion = {
+ let inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
+ inner.get(execution_id).map(|task| task.completion.subscribe())
+ };
+ if let Some(mut completion) = completion {
+ let _ = tokio::time::timeout(timeout, async {
+ while !*completion.borrow() {
+ if completion.changed().await.is_err() {
+ break;
+ }
+ }
+ })
+ .await;
+ }
+ self.completed_execution_result(execution_id)
}
/// Hands over the driver-specific interrupt handle (e.g. a MySQL
@@ -234,16 +309,10 @@ impl RunningQueries {
let inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
inner.get(execution_id).map(|task| task.completion.subscribe())
}) else {
- return CancellationWaitResult {
- requested: false,
- terminal: self.completed_execution_is_terminal(execution_id),
- };
+ return self.completed_execution_result(execution_id);
};
if !self.cancel(execution_id) {
- return CancellationWaitResult {
- requested: false,
- terminal: self.completed_execution_is_terminal(execution_id),
- };
+ return self.completed_execution_result(execution_id);
}
let terminal = tokio::time::timeout(timeout, async {
@@ -258,7 +327,11 @@ impl RunningQueries {
})
.await
.is_ok();
- CancellationWaitResult { requested: true, terminal }
+ CancellationWaitResult {
+ requested: true,
+ terminal,
+ database_terminal: self.completed_execution_result(execution_id).database_terminal,
+ }
}
pub fn cancel_connection(&self, connection_id: &str) -> usize {
@@ -337,7 +410,7 @@ impl RunningQueries {
(tasks, interrupts)
}
- fn remove(&self, execution_id: &str, registration_id: u64) {
+ fn remove(&self, execution_id: &str, registration_id: u64, database_terminal: bool) {
let removed = {
let mut inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
let should_remove = inner.get(execution_id).is_some_and(|task| task.registration_id == registration_id);
@@ -348,7 +421,7 @@ impl RunningQueries {
self.completed
.lock()
.unwrap_or_else(|e| e.into_inner())
- .insert(execution_id.to_string(), std::time::Instant::now());
+ .insert(execution_id.to_string(), (std::time::Instant::now(), database_terminal));
}
inner.remove(execution_id)
};
@@ -385,6 +458,7 @@ pub struct RegisteredQuery {
token: CancellationToken,
running_queries: RunningQueries,
detached: bool,
+ database_terminal: bool,
}
impl RegisteredQuery {
@@ -392,6 +466,22 @@ impl RegisteredQuery {
self.token.clone()
}
+ /// Task cleanup alone does not prove a database request has stopped.
+ pub fn finish_with_database_result<T>(mut self, result: &Result<T, crate::query::QueryExecutionError>) -> bool {
+ use crate::db::agent_driver::{AgentCallError, AgentErrorCategory, AgentErrorStage, AgentOperationOutcome};
+ use crate::query::QueryExecutionError;
+ self.database_terminal = match result {
+ Ok(_) => true,
+ Err(QueryExecutionError::Agent(AgentCallError::Structured { context, .. })) => {
+ context.operation_outcome == AgentOperationOutcome::NotStarted
+ || (context.category == AgentErrorCategory::Sql && context.stage == AgentErrorStage::Execute)
+ }
+ Err(QueryExecutionError::Canceled { operation_outcome: AgentOperationOutcome::NotStarted, .. }) => true,
+ _ => false,
+ };
+ self.database_terminal
+ }
+
/// Consumes the guard without immediately removing its `RunningQueries`
/// entry.
///
@@ -410,7 +500,7 @@ impl RegisteredQuery {
let registration_id = self.registration_id;
tokio::spawn(async move {
tokio::time::sleep(DETACHED_REGISTRATION_GRACE_PERIOD).await;
- running_queries.remove(&execution_id, registration_id);
+ running_queries.remove(&execution_id, registration_id, false);
});
}
@@ -439,7 +529,7 @@ impl RegisteredQuery {
impl Drop for RegisteredQuery {
fn drop(&mut self) {
if !self.detached {
- self.running_queries.remove(&self.execution_id, self.registration_id);
+ self.running_queries.remove(&self.execution_id, self.registration_id, self.database_terminal);
}
}
}
@@ -450,6 +540,85 @@ mod tests {
use std::time::{Duration, Instant};
use tokio_util::sync::CancellationToken;
+ #[tokio::test(start_paused = true)]
+ async fn wait_only_does_not_cancel_and_requires_a_real_database_result() {
+ let running = RunningQueries::default();
+ let registered = running.register_task_for_terminal_confirmation("type-step".to_string(), Default::default());
+ let interrupted = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
+ let flag = interrupted.clone();
+ running.register_interrupt("type-step", move || {
+ flag.store(true, std::sync::atomic::Ordering::SeqCst);
+ });
+ let pending = running.wait_for_completion("type-step", Duration::from_millis(1)).await;
+ assert!(!pending.requested && !pending.terminal);
+ assert_eq!(pending.database_terminal, Some(false));
+ assert!(!registered.token().is_cancelled());
+ assert!(!interrupted.load(std::sync::atomic::Ordering::SeqCst));
+ registered.finish_with_database_result(&Ok::<_, crate::query::QueryExecutionError>(()));
+ let completed = running.wait_for_completion("type-step", Duration::from_secs(1)).await;
+ assert!(!completed.requested && completed.terminal);
+ assert_eq!(completed.database_terminal, Some(true));
+ }
+
+ #[tokio::test]
+ async fn missing_expired_and_unproven_completion_do_not_claim_database_terminal() {
+ let running = RunningQueries::default();
+ let missing = running.wait_for_completion("missing", Duration::ZERO).await;
+ assert!(!missing.terminal);
+ assert_eq!(missing.database_terminal, Some(false));
+ let registered = running.register_task_for_terminal_confirmation("unknown".to_string(), Default::default());
+ drop(registered);
+ let unknown = running.wait_for_completion("unknown", Duration::ZERO).await;
+ assert!(unknown.terminal);
+ assert_eq!(unknown.database_terminal, Some(false));
+ running
+ .completed
+ .lock()
+ .unwrap()
+ .insert("expired".to_string(), (Instant::now() - DETACHED_REGISTRATION_GRACE_PERIOD, true));
+ let expired = running.wait_for_completion("expired", Duration::ZERO).await;
+ assert!(!expired.terminal);
+ assert_eq!(expired.database_terminal, Some(false));
+ }
+
+ #[tokio::test]
+ async fn transport_timeout_and_legacy_errors_do_not_prove_database_completion() {
+ use crate::db::agent_driver::{AgentCallError, AgentErrorStage, AgentOperationOutcome};
+ use crate::query::QueryExecutionError;
+ for error in [
+ QueryExecutionError::Agent(AgentCallError::Transport { message: "Lost RPC response".to_string() }),
+ QueryExecutionError::Timeout("Timed out".to_string()),
+ QueryExecutionError::Legacy("Unclassified error".to_string()),
+ QueryExecutionError::Canceled {
+ stage: AgentErrorStage::Execute,
+ operation_outcome: AgentOperationOutcome::Unknown,
+ },
+ ] {
+ let running = RunningQueries::default();
+ let registered = running.register_task_for_terminal_confirmation("step".to_string(), Default::default());
+ registered.finish_with_database_result::<()>(&Err(error));
+ let completed = running.wait_for_completion("step", Duration::ZERO).await;
+ assert!(completed.terminal);
+ assert_eq!(completed.database_terminal, Some(false));
+ }
+ }
+
+ #[tokio::test]
+ async fn typed_database_rejection_is_terminal_but_not_an_execution_success() {
+ use crate::db::agent_driver::{AgentCallError, AgentErrorContext};
+ let context: AgentErrorContext = serde_json::from_value(serde_json::json!({
+ "contractVersion": 1, "category": "sql", "retryable": false,
+ "sessionDisposition": "keep", "stage": "execute", "operationOutcome": "unknown"
+ }))
+ .unwrap();
+ let running = RunningQueries::default();
+ let registered = running.register_task_for_terminal_confirmation("rejected".to_string(), Default::default());
+ registered.finish_with_database_result::<()>(&Err(crate::query::QueryExecutionError::Agent(
+ AgentCallError::Structured { rpc_code: -32001, message: "Rejected by database".to_string(), context },
+ )));
+ assert_eq!(running.wait_for_completion("rejected", Duration::ZERO).await.database_terminal, Some(true));
+ }
+
#[test]
fn cancel_marks_registered_query_as_cancelled() {
let running = RunningQueries::default();
@@ -625,7 +794,7 @@ mod tests {
.completed
.lock()
.unwrap_or_else(|error| error.into_inner())
- .insert("exec-1".to_string(), Instant::now() - DETACHED_REGISTRATION_GRACE_PERIOD);
+ .insert("exec-1".to_string(), (Instant::now() - DETACHED_REGISTRATION_GRACE_PERIOD, false));
let result = running.cancel_and_wait("exec-1", Duration::from_secs(1)).await;
diff --git a/crates/dbx-core/src/schema/mod.rs b/crates/dbx-core/src/schema/mod.rs
index e294a851b1..fa4e3b3f50 100644
--- a/crates/dbx-core/src/schema/mod.rs
+++ b/crates/dbx-core/src/schema/mod.rs
@@ -26,6 +26,12 @@ mod external_table_filter_tests;
mod kingbase;
mod mongodb_columns;
pub mod oracle_routines;
+mod oracle_type_data;
+mod oracle_type_details;
+mod oracle_type_evolution;
+mod oracle_type_management;
+#[cfg(test)]
+mod oracle_type_transport_tests;
pub mod plugin_metadata;
#[cfg(test)]
mod plugin_metadata_tests;
@@ -3546,13 +3552,16 @@ mod tests {
}
#[test]
- fn supports_custom_type_details_covers_five_verified_families() {
+ fn supports_custom_type_details_preserves_pg_and_adds_oracle_families() {
for db_type in [
DatabaseType::Postgres,
DatabaseType::OpenGauss,
DatabaseType::Gaussdb,
DatabaseType::Kingbase,
DatabaseType::Vastbase,
+ DatabaseType::Oracle,
+ DatabaseType::OceanbaseOracle,
+ DatabaseType::Dameng,
] {
assert!(supports_custom_type_details(&test_connection_config(db_type)), "{db_type:?}");
}
@@ -4601,18 +4610,69 @@ done
#[test]
fn mysql_event_object_source_is_read_only() {
- let source = finalize_object_source(db::ObjectSource {
- name: "event_daily_sync".to_string(),
- object_type: db::ObjectSourceKind::Event,
- schema: None,
- source: "CREATE EVENT event_daily_sync ON SCHEDULE EVERY 1 DAY DO SELECT 1".to_string(),
- editable: None,
- routine_parameters: None,
- });
+ let source = finalize_object_source(
+ db::ObjectSource {
+ name: "event_daily_sync".to_string(),
+ object_type: db::ObjectSourceKind::Event,
+ schema: None,
+ source: "CREATE EVENT event_daily_sync ON SCHEDULE EVERY 1 DAY DO SELECT 1".to_string(),
+ editable: None,
+ routine_parameters: None,
+ },
+ None,
+ );
assert_eq!(source.editable, Some(false));
}
+ #[test]
+ fn oracle_family_type_sources_are_editable_without_changing_xugu_or_routines() {
+ for db_type in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle, DatabaseType::Dameng, DatabaseType::Xugu] {
+ let config = test_connection_config(db_type);
+ for kind in [db::ObjectSourceKind::Type, db::ObjectSourceKind::TypeBody, db::ObjectSourceKind::Function] {
+ let source = finalize_object_source(
+ db::ObjectSource {
+ name: "Mixed Type".to_string(),
+ object_type: kind.clone(),
+ schema: Some("Exact Owner".to_string()),
+ source: "CREATE TYPE ...".to_string(),
+ editable: Some(true),
+ routine_parameters: None,
+ },
+ Some(&config),
+ );
+ let newly_editable = db_type != DatabaseType::Xugu
+ && matches!(kind, db::ObjectSourceKind::Type | db::ObjectSourceKind::TypeBody);
+ assert_eq!(
+ source.editable,
+ Some(
+ db_type == DatabaseType::Xugu
+ || newly_editable
+ || !matches!(kind, db::ObjectSourceKind::Type | db::ObjectSourceKind::TypeBody)
+ ),
+ "{db_type:?} {kind:?}"
+ );
+ }
+ }
+ let mut config = test_connection_config(DatabaseType::Jdbc);
+ config.connection_string = Some("jdbc:oceanbase:oracle://localhost:2881/APP".into());
+ config.jdbc_driver_class = Some("com.oceanbase.jdbc.Driver".into());
+ for kind in [db::ObjectSourceKind::Type, db::ObjectSourceKind::TypeBody] {
+ let source = finalize_object_source(
+ db::ObjectSource {
+ name: "Mixed Type".into(),
+ object_type: kind,
+ schema: Some("Exact Owner".into()),
+ source: "CREATE TYPE ...".into(),
+ editable: Some(true),
+ routine_parameters: None,
+ },
+ Some(&config),
+ );
+ assert_eq!(source.editable, Some(true));
+ }
+ }
+
#[test]
fn mysql_object_source_sql_emits_show_create_materialized_view() {
// Regression for the review comment: Doris / StarRocks ride on the MySQL
@@ -7503,9 +7563,13 @@ async fn list_objects_once(
if let Some(agent_client) = extract_pool!(pool_handle.as_ref(), Agent) {
let is_oracle = db_config.as_ref().is_some_and(|config| config.db_type == DatabaseType::Oracle);
let is_oceanbase = db_config.as_ref().is_some_and(|config| config.db_type == DatabaseType::OceanbaseOracle);
- let use_oracle_agent_paging = db_config.as_ref().is_some_and(is_default_oracle_agent_config);
+ // Type requests can use the shared Go handler's ROWNUM paging on
+ // legacy/OCI profiles too; retain the old fallback for other kinds.
+ let use_oracle_agent_paging = db_config.as_ref().is_some_and(is_default_oracle_agent_config)
+ || (is_oracle && object_types_only_custom_types(object_types));
let use_agent_paging = use_oracle_agent_paging || is_oceanbase;
let filter_locally_after_oracle_comments = is_oracle
+ && !object_types_only_custom_types(object_types)
&& !object_types.is_some_and(|types| types.len() == 1 && types[0].eq_ignore_ascii_case("INDEX"))
&& filter.is_some_and(|filter| !filter.trim().is_empty());
let timeout_duration = agent_metadata_timeout(db_config.as_ref());
@@ -11309,14 +11373,15 @@ async fn read_mysql_object_source_row(
/// separate from listing support so a future per-kind DDL capability can be
/// toggled independently.
fn supports_custom_type_details(config: &ConnectionConfig) -> bool {
- matches!(
- config.db_type,
- DatabaseType::Postgres
- | DatabaseType::OpenGauss
- | DatabaseType::Gaussdb
- | DatabaseType::Kingbase
- | DatabaseType::Vastbase
- )
+ oracle_type_details::dialect(config).is_some()
+ || matches!(
+ config.db_type,
+ DatabaseType::Postgres
+ | DatabaseType::OpenGauss
+ | DatabaseType::Gaussdb
+ | DatabaseType::Kingbase
+ | DatabaseType::Vastbase
+ )
}
pub async fn get_custom_type_details_core(
@@ -11332,6 +11397,401 @@ pub async fn get_custom_type_details_core(
.await
}
+/// Read a type-management snapshot through the same Agent/JDBC query boundary
+/// as custom-type details. This is intentionally a narrow dictionary adapter;
+/// execution remains a separate, explicit user-confirmed operation.
+pub async fn get_oracle_type_management_snapshot_core(
+ state: &AppState,
+ connection_id: &str,
+ database: &str,
+ owner: &str,
+ name: &str,
+) -> Result<db::OracleTypeManagementSnapshot, String> {
+ get_oracle_type_management_snapshot_with_objects_core(state, connection_id, database, owner, name, &[]).await
+}
+
+/// Known identities let recovery inspect objects whose dependency edges vanished
+/// after an earlier confirmed DROP. Definitions still come from the live database.
+pub async fn get_oracle_type_management_snapshot_with_objects_core(
+ state: &AppState,
+ connection_id: &str,
+ database: &str,
+ owner: &str,
+ name: &str,
+ known_objects: &[db::OracleTypeManagementObjectKey],
+) -> Result<db::OracleTypeManagementSnapshot, String> {
+ if known_objects.len() > 500 {
+ return Err("TYPE recovery can inspect at most 500 known object identities.".into());
+ }
+ let config = connection_config(state, connection_id).await;
+ let config = config.as_ref().ok_or_else(|| "connection not found".to_string())?;
+ let dialect = oracle_type_details::dialect(config)
+ .ok_or_else(|| "TYPE management is supported only for Oracle-family connections".to_string())?;
+ let run = |sql: String| run_oracle_type_management_query(state, connection_id, database, sql, 10_000);
+ let (acting_user, acting_user_read) = oracle_type_management::acting_user(&run).await;
+ let (dependencies, dependencies_read) = oracle_type_management::dependencies(dialect, owner, name, &run).await;
+ let (direct_privileges, privileges_read) =
+ oracle_type_management::direct_privileges(dialect, owner, name, &run).await;
+
+ let mut objects = Vec::new();
+ let mut identities = vec![
+ (owner.to_string(), name.to_string(), "TYPE".to_string()),
+ (owner.to_string(), name.to_string(), "TYPE BODY".to_string()),
+ ];
+ identities.extend(known_objects.iter().map(|key| (key.owner.clone(), key.name.clone(), key.object_type.clone())));
+ for dependency in &dependencies {
+ identities.push((dependency.owner.clone(), dependency.name.clone(), dependency.object_type.clone()));
+ if dependency.object_type == "TYPE" {
+ identities.push((dependency.owner.clone(), dependency.name.clone(), "TYPE BODY".to_string()));
+ }
+ }
+ let mut object_keys = HashSet::new();
+ let mut persistent_references = Vec::new();
+ let mut persistent_references_read = oracle_type_management::available();
+ for (object_owner, object_name, object_type) in identities {
+ if !object_keys.insert((object_owner.clone(), object_name.clone(), object_type.clone())) {
+ continue;
+ }
+ let mut object =
+ oracle_type_management::object_metadata(dialect, &object_owner, &object_name, &object_type, &run).await;
+ let source_kind = match object_type.as_str() {
+ "TYPE" => Some(db::ObjectSourceKind::Type),
+ "TYPE BODY" | "CLASS_BODY" => Some(db::ObjectSourceKind::TypeBody),
+ "CLASS" | "CLLT" => Some(db::ObjectSourceKind::Type),
+ "FUNCTION" => Some(db::ObjectSourceKind::Function),
+ "PROCEDURE" => Some(db::ObjectSourceKind::Procedure),
+ "PACKAGE" => Some(db::ObjectSourceKind::Package),
+ "PACKAGE BODY" => Some(db::ObjectSourceKind::PackageBody),
+ "VIEW" => Some(db::ObjectSourceKind::View),
+ "MATERIALIZED VIEW" => Some(db::ObjectSourceKind::MaterializedView),
+ "TRIGGER" => Some(db::ObjectSourceKind::Trigger),
+ _ => None,
+ };
+ let (source, source_read) = if object.exists == Some(false) {
+ (None, oracle_type_management::available())
+ } else if let Some(source_kind) = source_kind.clone() {
+ match get_object_source_core(
+ state,
+ connection_id,
+ database,
+ &object_owner,
+ &object_name,
+ source_kind,
+ None,
+ None,
+ )
+ .await
+ {
+ Ok(source) => (
+ Some(source.source),
+ db::TypeMetadataRead { state: db::TypeMetadataState::Available, reason: None },
+ ),
+ Err(error) => {
+ (None, db::TypeMetadataRead { state: db::TypeMetadataState::Unavailable, reason: Some(error) })
+ }
+ }
+ } else {
+ (
+ None,
+ db::TypeMetadataRead {
+ state: db::TypeMetadataState::Unsupported,
+ reason: Some(format!("Source for {object_type} is not available through the type manager")),
+ },
+ )
+ };
+ object.source = source;
+ object.source_read = source_read;
+ object.source_fingerprint = source_kind.and_then(|kind| {
+ object.source.as_ref().and_then(|source| {
+ dbx_sql::object_source_sql::build_oracle_type_management_source(
+ dbx_sql::object_source_sql::EditableObjectSourceSqlInput {
+ database_type: match dialect {
+ oracle_type_details::Dialect::Oracle => DatabaseType::Oracle,
+ oracle_type_details::Dialect::OceanBase => DatabaseType::OceanbaseOracle,
+ oracle_type_details::Dialect::Dameng => DatabaseType::Dameng,
+ },
+ object_type: kind,
+ schema: Some(object_owner.clone()),
+ name: object_name.clone(),
+ source: source.clone(),
+ },
+ )
+ .ok()
+ .map(|(_, fingerprint)| fingerprint)
+ })
+ });
+ let is_type = object_type == "TYPE";
+ let (object_privileges, object_privileges_read) = if is_type {
+ if object_owner == owner && object_name == name {
+ (direct_privileges.clone(), privileges_read.clone())
+ } else {
+ oracle_type_management::direct_privileges(dialect, &object_owner, &object_name, &run).await
+ }
+ } else {
+ (
+ Vec::new(),
+ db::TypeMetadataRead {
+ state: db::TypeMetadataState::Unsupported,
+ reason: Some(
+ "Direct grants are read only for objects that the type manager may replace".to_string(),
+ ),
+ },
+ )
+ };
+ object.direct_privileges = object_privileges;
+ object.privileges_read = object_privileges_read;
+ if is_type {
+ let (references, read) =
+ oracle_type_management::persistent_references(dialect, &object_owner, &object_name, &run).await;
+ persistent_references.extend(references);
+ if read.state != db::TypeMetadataState::Available {
+ persistent_references_read.state = db::TypeMetadataState::Incomplete;
+ let reason = format!(
+ "{object_owner}.{object_name}: {}",
+ read.reason.unwrap_or_else(|| "Persistent references are unknown".into())
+ );
+ persistent_references_read.reason.get_or_insert_with(String::new).push_str(&format!("{reason}\n"));
+ }
+ }
+ objects.push(object);
+ }
+ let root = objects
+ .iter()
+ .find(|object| object.owner == owner && object.name == name && object.object_type == "TYPE")
+ .unwrap();
+ let body = objects
+ .iter()
+ .find(|object| object.owner == owner && object.name == name && object.object_type == "TYPE BODY")
+ .unwrap();
+ let (type_source, type_source_read) = (root.source.clone(), root.source_read.clone());
+ let (body_source, body_source_read) = (body.source.clone(), body.source_read.clone());
+ let (details, details_read) = if root.exists == Some(false) {
+ (None, oracle_type_management::available())
+ } else {
+ match get_custom_type_details_core(state, connection_id, database, owner, name).await {
+ Ok(details) => (Some(details), oracle_type_management::available()),
+ Err(error) => (None, oracle_type_management::unavailable(error)),
+ }
+ };
+ Ok(db::OracleTypeManagementSnapshot {
+ target: db::OracleTypeManagementTarget {
+ connection_id: connection_id.to_string(),
+ database: database.to_string(),
+ owner: owner.to_string(),
+ name: name.to_string(),
+ },
+ acting_user,
+ acting_user_read,
+ visibility_scope: "current-user-visible-dictionaries".to_string(),
+ details,
+ details_read,
+ type_source,
+ type_source_read,
+ body_source,
+ body_source_read,
+ objects,
+ dependencies,
+ dependencies_read,
+ persistent_references,
+ persistent_references_read,
+ direct_privileges,
+ privileges_read,
+ })
+}
+
+/// Shared query transport for TYPE metadata and bounded scalar verification.
+/// These are ordinary reads on the existing Agent/ExternalDriver RPC contract.
+async fn run_oracle_type_management_query(
+ state: &AppState,
+ connection_id: &str,
+ database: &str,
+ sql: String,
+ max_rows: usize,
+) -> Result<db::QueryResult, String> {
+ let config = connection_config(state, connection_id).await.ok_or("connection not found")?;
+ if oracle_type_details::dialect(&config).is_none() {
+ return Err("TYPE management requires an Oracle-family connection".into());
+ }
+ let timeout = agent_metadata_timeout(Some(&config));
+ let pool_key = state.get_or_create_metadata_pool_for_session(connection_id, Some(database), None).await?;
+ let response: oracle_type_management::QueryResponse = match clone_metadata_pool(state, &pool_key).await.ok_or("Pool not found")? {
+ PoolKind::Agent(client) => client.lock().await.execute_query_with_timeout(agent_execute_query_params(&sql, if database.is_empty() { None } else { Some(database) }, None, QueryExecutionOptions { max_rows: Some(max_rows), ..Default::default() }), timeout).await,
+ PoolKind::ExternalDriver { config, session, .. } => session.invoke_with_timeout("executeQuery", serde_json::json!({ "connection": config.as_ref(), "database": database, "sql": sql, "maxRows": max_rows, "fetchSize": 1000 }), timeout).await,
+ _ => Err("Oracle-family TYPE management requires an Agent or JDBC query transport".into()),
+ }?;
+ response.into_result()
+}
+
+pub async fn verify_oracle_type_data_core(
+ state: &AppState,
+ input: db::OracleTypeDataRequest,
+) -> Result<db::OracleTypeDataResult, String> {
+ let target = input.target.clone();
+ let config = connection_config(state, &target.connection_id).await.ok_or("connection not found")?;
+ let dialect =
+ oracle_type_details::dialect(&config).ok_or("TYPE data verification requires an Oracle-family connection")?;
+ if input.action == "register" {
+ let mapping = input.mapping.as_ref().ok_or("A permanent data mapping is required")?;
+ let snapshot = get_oracle_type_management_snapshot_core(
+ state,
+ &target.connection_id,
+ &target.database,
+ &target.owner,
+ &target.name,
+ )
+ .await?;
+ // Registration is a read-only, full-table proof, not permission to run
+ // TYPE DDL. DM can identify the table while its UDT column code remains
+ // unknown; the execution planner still requires complete live references.
+ if !snapshot
+ .persistent_references
+ .iter()
+ .any(|r| r.owner == mapping.source.owner && r.table_name == mapping.source.name)
+ {
+ return Err(
+ "Register the original complete data projection before changing or removing its live TYPE reference"
+ .into(),
+ );
+ }
+ }
+ oracle_type_data::read(dialect, input, |sql| {
+ run_oracle_type_management_query(state, &target.connection_id, &target.database, sql, 10_002)
+ })
+ .await
+}
+
+pub async fn prepare_oracle_type_evolution_core(
+ state: &AppState,
+ input: db::OracleTypeEvolutionRequest,
+) -> Result<db::OracleTypeEvolutionManifest, String> {
+ let target = input.target.clone();
+ let config = connection_config(state, &target.connection_id).await.ok_or("connection not found")?;
+ if oracle_type_details::dialect(&config) != Some(oracle_type_details::Dialect::Oracle) {
+ return Err("Native ALTER TYPE evolution is not enabled for this database dialect; retain the source or use the verified manual mapping route".into());
+ }
+ let snapshot = get_oracle_type_management_snapshot_core(
+ state,
+ &target.connection_id,
+ &target.database,
+ &target.owner,
+ &target.name,
+ )
+ .await?;
+ oracle_type_evolution::read(input, snapshot, |sql| {
+ run_oracle_type_management_query(state, &target.connection_id, &target.database, sql, 10_000)
+ })
+ .await
+}
+
+/// Build one strictly-targeted TYPE-management statement group. This endpoint
+/// validates and previews only; the caller must obtain explicit confirmation
+/// and execute statements through the normal guarded query path.
+pub fn build_oracle_type_management_sql(
+ input: db::OracleTypeManagementSqlInput,
+) -> Result<db::OracleTypeManagementSqlResult, String> {
+ if !matches!(input.database_type, DatabaseType::Oracle | DatabaseType::OceanbaseOracle | DatabaseType::Dameng) {
+ return Err("TYPE management SQL is supported only for Oracle-family databases.".into());
+ }
+ use db::OracleTypeManagementSqlOperation as Operation;
+ use dbx_sql::db_admin_sql::{
+ build_drop_object_sql, build_oracle_type_grant_sql, DatabaseObjectType, DropObjectSqlOptions,
+ OracleTypeGrantSqlOptions,
+ };
+ use dbx_sql::object_source_sql::{build_oracle_type_management_source, EditableObjectSourceSqlInput};
+
+ let database_type = input.database_type;
+ let owner = input.owner.clone();
+ let name = input.name.clone();
+ let object_source = move |object_type: db::ObjectSourceKind, source: Option<String>| {
+ let source = source.ok_or_else(|| "TYPE source text is required for a save operation.".to_string())?;
+ let source_input = EditableObjectSourceSqlInput {
+ database_type,
+ object_type: object_type.clone(),
+ schema: Some(owner.clone()),
+ name: name.clone(),
+ source,
+ };
+ let (sql, fingerprint) = if object_type == db::ObjectSourceKind::Trigger {
+ dbx_sql::object_source_sql::build_oracle_type_management_trigger_source(
+ source_input,
+ input.trigger_enabled.ok_or("The verified trigger firing state is required")?,
+ )?
+ } else {
+ build_oracle_type_management_source(source_input)?
+ };
+ Ok(db::OracleTypeManagementSqlResult { statements: vec![sql], source_fingerprint: Some(fingerprint) })
+ };
+ let statements = match input.operation {
+ Operation::SaveSpec => return object_source(db::ObjectSourceKind::Type, input.source),
+ Operation::SaveBody => return object_source(db::ObjectSourceKind::TypeBody, input.source),
+ Operation::RebuildSource => {
+ return object_source(input.object_type.ok_or("Dependency object type is required")?, input.source)
+ }
+ Operation::CompileSpec => {
+ if database_type != DatabaseType::Oracle {
+ return Err("Native TYPE specification compilation is only enabled for Oracle".into());
+ }
+ let validated = object_source(db::ObjectSourceKind::Type, input.source)?;
+ let quoted = |value: &str| format!("\"{}\"", value.replace('"', "\"\""));
+ return Ok(db::OracleTypeManagementSqlResult {
+ statements: vec![format!(
+ "ALTER TYPE {}.{} COMPILE SPECIFICATION;",
+ quoted(&input.owner),
+ quoted(&input.name)
+ )],
+ source_fingerprint: validated.source_fingerprint,
+ });
+ }
+ Operation::CompileTrigger => {
+ let source = input.source.ok_or("The unchanged trigger definition is required")?;
+ input.trigger_enabled.ok_or("The verified trigger firing state is required")?;
+ let (_, fingerprint) = build_oracle_type_management_source(EditableObjectSourceSqlInput {
+ database_type,
+ object_type: db::ObjectSourceKind::Trigger,
+ schema: Some(input.owner.clone()),
+ name: input.name.clone(),
+ source,
+ })?;
+ let quoted = |value: &str| format!("\"{}\"", value.replace('"', "\"\""));
+ return Ok(db::OracleTypeManagementSqlResult {
+ statements: vec![format!("ALTER TRIGGER {}.{} COMPILE;", quoted(&input.owner), quoted(&input.name))],
+ source_fingerprint: Some(fingerprint),
+ });
+ }
+ Operation::DropSpec => vec![build_drop_object_sql(DropObjectSqlOptions {
+ database_type: Some(input.database_type),
+ object_type: DatabaseObjectType::Type,
+ schema: Some(input.owner),
+ name: input.name,
+ signature: None,
+ identifier_quote: None,
+ })],
+ Operation::DropBody => vec![build_drop_object_sql(DropObjectSqlOptions {
+ database_type: Some(input.database_type),
+ object_type: DatabaseObjectType::TypeBody,
+ schema: Some(input.owner),
+ name: input.name,
+ signature: None,
+ identifier_quote: None,
+ })],
+ Operation::GrantExecute | Operation::GrantPrivilege => {
+ vec![build_oracle_type_grant_sql(OracleTypeGrantSqlOptions {
+ database_type: input.database_type,
+ owner: input.owner,
+ type_name: input.name,
+ grantee: input.grantee.ok_or_else(|| "TYPE grant grantee is required.".to_string())?,
+ grantable: input.grantable,
+ privilege: if input.operation == Operation::GrantExecute {
+ "EXECUTE".into()
+ } else {
+ input.privilege.ok_or("TYPE privilege is required")?
+ },
+ })?]
+ }
+ };
+ Ok(db::OracleTypeManagementSqlResult { statements, source_fingerprint: None })
+}
+
async fn get_custom_type_details_once(
state: &AppState,
connection_id: &str,
@@ -11347,6 +11807,54 @@ async fn get_custom_type_details_once(
if !supports_custom_type_details(config) {
return Err(format!("custom type details are not supported for {:?} connections", config.db_type));
}
+ if let Some(dialect) = oracle_type_details::dialect(config) {
+ let pool = clone_metadata_pool(state, &pool_key).await.ok_or("Pool not found")?;
+ let timeout = agent_metadata_timeout(Some(config));
+ return match pool {
+ PoolKind::Agent(client) => {
+ oracle_type_details::read(dialect, schema, name, |sql| {
+ let client = client.clone();
+ async move {
+ let mut client = client.lock().await;
+ client
+ .execute_query_with_timeout(
+ agent_execute_query_params(
+ &sql,
+ if database.is_empty() { None } else { Some(database) },
+ // Dictionaries use an explicit OWNER predicate;
+ // do not switch the borrowed session's schema.
+ None,
+ QueryExecutionOptions { max_rows: Some(10_000), ..Default::default() },
+ ),
+ timeout,
+ )
+ .await
+ }
+ })
+ .await
+ }
+ PoolKind::ExternalDriver { config, session, .. } => {
+ oracle_type_details::read(dialect, schema, name, |sql| {
+ let session = session.clone();
+ let config = config.clone();
+ async move {
+ session
+ .invoke_with_timeout(
+ "executeQuery",
+ serde_json::json!({
+ "connection": config.as_ref(), "database": database,
+ "sql": sql, "maxRows": 10_000, "fetchSize": 1000,
+ }),
+ timeout,
+ )
+ .await
+ }
+ })
+ .await
+ }
+ _ => Err("Oracle-family type details require an Agent or JDBC query transport".to_string()),
+ };
+ }
{
let pool_handle = state.pool_handle(&pool_key).await;
if let Some(client) = extract_pool!(pool_handle.as_ref(), Agent) {
@@ -11374,6 +11882,7 @@ pub async fn get_object_source_core(
signature: Option<&str>,
relation_name: Option<&str>,
) -> Result<db::ObjectSource, String> {
+ let config = connection_config(state, connection_id).await;
let source = retry_metadata_connection(state, connection_id, Some(database), || {
get_object_source_once(
state,
@@ -11387,7 +11896,7 @@ pub async fn get_object_source_core(
)
})
.await?;
- Ok(finalize_object_source(source))
+ Ok(finalize_object_source(source, config.as_ref()))
}
pub async fn get_event_info_core(
@@ -11443,12 +11952,16 @@ pub async fn get_event_info_core(
}
}
-fn finalize_object_source(mut source: db::ObjectSource) -> db::ObjectSource {
+fn finalize_object_source(mut source: db::ObjectSource, config: Option<&ConnectionConfig>) -> db::ObjectSource {
if matches!(source.object_type, db::ObjectSourceKind::Procedure | db::ObjectSourceKind::Function) {
source.source = normalize_routine_object_source(source.source);
}
if matches!(source.object_type, db::ObjectSourceKind::Event) {
source.editable = Some(false);
+ } else if matches!(source.object_type, db::ObjectSourceKind::Type | db::ObjectSourceKind::TypeBody)
+ && config.and_then(oracle_type_details::dialect).is_some()
+ {
+ source.editable = Some(true);
}
source
}
@@ -11724,17 +12237,19 @@ fn oracle_owner_filter(schema: &str) -> String {
}
pub fn oracle_list_objects_sql(schema: &str) -> String {
- oracle_list_objects_sql_for_owner(&oracle_owner_filter(schema))
+ let type_owner = if schema.is_empty() { "USER".to_string() } else { sql_string(schema) };
+ oracle_list_objects_sql_for_owner(&oracle_owner_filter(schema), &type_owner)
}
-fn oracle_list_objects_sql_for_owner(owner: &str) -> String {
+fn oracle_list_objects_sql_for_owner(owner: &str, type_owner: &str) -> String {
format!(
- "SELECT o.object_name, CASE o.object_type WHEN 'PACKAGE BODY' THEN 'PACKAGE_BODY' ELSE o.object_type END AS object_type, o.owner, \
+ "SELECT o.object_name, CASE o.object_type WHEN 'PACKAGE BODY' THEN 'PACKAGE_BODY' WHEN 'TYPE BODY' THEN 'TYPE_BODY' ELSE o.object_type END AS object_type, o.owner, \
i.table_owner AS parent_schema, i.table_name AS parent_name \
FROM all_objects o LEFT JOIN all_indexes i ON o.object_type = 'INDEX' AND i.owner = o.owner AND i.index_name = o.object_name \
- WHERE o.owner = {owner} AND o.object_type IN ('TABLE', 'VIEW', 'PROCEDURE', 'FUNCTION', 'SEQUENCE', 'PACKAGE', 'PACKAGE BODY', 'INDEX') \
+ WHERE ((o.owner = {owner} AND o.object_type IN ('TABLE', 'VIEW', 'PROCEDURE', 'FUNCTION', 'SEQUENCE', 'PACKAGE', 'PACKAGE BODY', 'INDEX')) \
+ OR (o.owner = {type_owner} AND o.object_type IN ('TYPE', 'TYPE BODY'))) \
AND (o.object_type <> 'INDEX' OR i.generated = 'N' OR i.generated IS NULL) \
- ORDER BY CASE o.object_type WHEN 'TABLE' THEN 0 WHEN 'VIEW' THEN 1 WHEN 'PROCEDURE' THEN 2 WHEN 'FUNCTION' THEN 3 WHEN 'SEQUENCE' THEN 4 WHEN 'PACKAGE' THEN 5 WHEN 'PACKAGE BODY' THEN 6 ELSE 7 END, o.object_name"
+ ORDER BY CASE o.object_type WHEN 'TABLE' THEN 0 WHEN 'VIEW' THEN 1 WHEN 'PROCEDURE' THEN 2 WHEN 'FUNCTION' THEN 3 WHEN 'SEQUENCE' THEN 4 WHEN 'PACKAGE' THEN 5 WHEN 'PACKAGE BODY' THEN 6 ELSE 7 END, o.object_name, o.object_type"
)
}
@@ -11802,7 +12317,7 @@ async fn oracle_agent_list_objects(
) -> Result<ObjectListOutcome, String> {
let index_only = object_types.is_some_and(|types| types.len() == 1 && types[0].eq_ignore_ascii_case("INDEX"));
let mut sql = if exact_identity {
- oracle_list_objects_sql_for_owner(&sql_string(schema))
+ oracle_list_objects_sql_for_owner(&sql_string(schema), &sql_string(schema))
} else {
oracle_list_objects_sql(schema)
};
@@ -11832,6 +12347,9 @@ async fn oracle_agent_list_objects(
QueryExecutionOptions { max_rows: Some(page_size), ..Default::default() },
);
let result: db::QueryResult = client.execute_query_with_timeout(params, timeout_duration).await?;
+ if (result.truncated || result.has_more) && result.rows.is_empty() {
+ return Err("Oracle object list was truncated without returning a page".to_string());
+ }
let row_count = result.rows.len();
objects.extend(result.rows.into_iter().filter_map(|row| {
let name = row.first()?.as_str()?.to_string();
diff --git a/crates/dbx-core/src/schema/oracle_type_data.rs b/crates/dbx-core/src/schema/oracle_type_data.rs
new file mode 100644
index 0000000000..d29b890c36
--- /dev/null
+++ b/crates/dbx-core/src/schema/oracle_type_data.rs
@@ -0,0 +1,1579 @@
+//! Durable scalar evidence for manual TYPE migrations. A complete bounded read
+//! is sorted by its exact byte encoding in Rust, never by database collation or
+//! unstable row numbers. Duplicate rows are deliberately retained.
+use super::{oracle_type_details::Dialect, oracle_type_management::Rows, sql_string};
+use crate::db::{
+ self, OracleTypeDataBaseline, OracleTypeDataManifest, OracleTypeDataMappingInput, OracleTypeDataProjection,
+ OracleTypeDataRelation, OracleTypeDataRelationKey, OracleTypeDataRequest, OracleTypeDataResult, TypeMetadataState,
+};
+use dbx_sql::oracle_type_migration_sql::{
+ oceanbase_scalar_insert_columns, oceanbase_table_read_only_from_ddl, validate_scalar_insert, ScalarColumn,
+ ScalarType,
+};
+use serde_json::{json, Value};
+use sha2::{Digest, Sha256};
+use std::collections::{HashSet, VecDeque};
+use std::future::Future;
+
+const MAX_ROWS: usize = 10_000;
+const MAX_BYTES: usize = 8 * 1024 * 1024;
+const MAX_FIELDS: usize = 128;
+fn quote(value: &str) -> String {
+ format!("\"{}\"", value.replace('"', "\"\""))
+}
+fn qualified(key: &OracleTypeDataRelationKey) -> String {
+ format!("{}.{}", quote(&key.owner), quote(&key.name))
+}
+fn predicate(key: &OracleTypeDataRelationKey) -> String {
+ format!("OWNER={} AND TABLE_NAME={}", sql_string(&key.owner), sql_string(&key.name))
+}
+pub(super) fn checked(rows: &Rows) -> Result<(), String> {
+ if rows.read.state == TypeMetadataState::Available {
+ Ok(())
+ } else {
+ Err(rows.read.reason.clone().unwrap_or_else(|| "A complete data/metadata read is required".into()))
+ }
+}
+pub(super) fn raw_metadata(rows: &Rows) -> Value {
+ let mut values: Vec<_> = rows
+ .rows
+ .iter()
+ .map(|row| {
+ let mut fields: Vec<_> =
+ rows.columns.iter().enumerate().map(|(i, name)| (name.to_uppercase(), row[i].clone())).collect();
+ fields.sort_by(|a, b| a.0.cmp(&b.0));
+ fields
+ })
+ .collect();
+ values.sort_by_key(|value| serde_json::to_string(value).unwrap_or_default());
+ json!(values)
+}
+fn required_text(rows: &Rows, row: &[Value], key: &str) -> Result<String, String> {
+ rows.text(row, key)
+ .ok_or_else(|| format!("Cannot verify {key}; prepare a supported scalar projection in the SQL editor"))
+}
+fn scalar_type(rows: &Rows, row: &[Value], prefix: &str) -> Result<ScalarType, String> {
+ let name = required_text(rows, row, &format!("{prefix}TYPE"))?.to_uppercase();
+ let dimension = |key: &str| rows.text(row, key).and_then(|s| s.parse::<i32>().ok());
+ let declaration = match name.as_str() {
+ "NUMBER" | "DECIMAL" | "NUMERIC" => match dimension("DATA_PRECISION") {
+ Some(p) => format!("NUMBER({p},{})", dimension("DATA_SCALE").ok_or("Numeric scale is unknown")?),
+ None if rows.value(row, "DATA_SCALE").is_none() => "NUMBER".into(),
+ _ => return Err("An unconstrained numeric projection with a fixed/unknown scale needs explicit scalar preparation".into()),
+ },
+ "VARCHAR2" | "CHAR" => {
+ let semantics = match rows.text(row, "CHAR_USED").as_deref() { Some("B") => "BYTE", Some("C") => "CHAR", _ => return Err("Character length semantics are unknown".into()) };
+ let size = dimension(if semantics == "CHAR" { "CHAR_LENGTH" } else { "DATA_LENGTH" }).ok_or("Character length is unknown")?;
+ format!("{name}({size} {semantics})")
+ }
+ "NVARCHAR2" | "NCHAR" => format!("{name}({})", dimension("CHAR_LENGTH").ok_or("National-character length is unknown")?),
+ "RAW" => format!("RAW({})", dimension("DATA_LENGTH").ok_or("RAW length is unknown")?),
+ "DATE" => "DATE".into(),
+ ty if ty == "TIMESTAMP" || (ty.starts_with("TIMESTAMP(") && ty.ends_with(')')) => format!("TIMESTAMP({})", dimension("DATA_SCALE").ok_or("Timestamp precision is unknown")?),
+ _ => return Err(format!("{name} is not a supported lossless scalar projection; LOB, floating, collection and zoned values need preparation in the SQL editor")),
+ };
+ ScalarType::parse(&declaration)
+}
+
+async fn oceanbase_table_definition<F, Fut>(key: &OracleTypeDataRelationKey, run: &mut F) -> Result<String, String>
+where
+ F: FnMut(String) -> Fut,
+ Fut: Future<Output = Result<db::QueryResult, String>>,
+{
+ let definition = Rows::new(
+ run(format!(
+ "SELECT DBMS_METADATA.GET_DDL('TABLE', {}, {}) AS TABLE_DDL FROM DUAL",
+ sql_string(&key.name),
+ sql_string(&key.owner)
+ ))
+ .await,
+ &["TABLE_DDL"],
+ );
+ checked(&definition)?;
+ if definition.rows.len() != 1 {
+ return Err("The complete exact native table definition is unavailable".into());
+ }
+ definition
+ .value(&definition.rows[0], "TABLE_DDL")
+ .and_then(Value::as_str)
+ .map(String::from)
+ .ok_or_else(|| "The complete native table definition must be a string".into())
+}
+
+/// Full user-visible projection, including invisible user columns and an atomic
+/// null flag for each object value (an all-null object is not an atomic NULL).
+pub(super) async fn describe<F, Fut>(
+ dialect: Dialect,
+ key: &OracleTypeDataRelationKey,
+ run: &mut F,
+) -> Result<OracleTypeDataRelation, String>
+where
+ F: FnMut(String) -> Fut,
+ Fut: Future<Output = Result<db::QueryResult, String>>,
+{
+ if key.owner.is_empty() || key.name.is_empty() {
+ return Err("Supply the exact owner and table name".into());
+ }
+ let objects = Rows::new(run(format!("SELECT TO_CHAR(OBJECT_ID) AS OBJECT_ID, OBJECT_TYPE, TEMPORARY FROM ALL_OBJECTS WHERE OWNER={} AND OBJECT_NAME={} AND SUBOBJECT_NAME IS NULL", sql_string(&key.owner), sql_string(&key.name))).await, &["OBJECT_ID", "OBJECT_TYPE", "TEMPORARY"]);
+ checked(&objects)?;
+ if objects.rows.len() != 1
+ || objects.text(&objects.rows[0], "OBJECT_TYPE").as_deref() != Some("TABLE")
+ || objects.yes_no(&objects.rows[0], "TEMPORARY") != Some(false)
+ {
+ return Err(
+ "The relation must be one exact permanent ordinary table, not a view, synonym or temporary relation".into(),
+ );
+ }
+ let object_id = required_text(&objects, &objects.rows[0], "OBJECT_ID")?;
+ let tables = Rows::new(
+ run(format!("SELECT * FROM ALL_TABLES WHERE {}", predicate(key))).await,
+ &["OWNER", "TABLE_NAME", "TEMPORARY", "NESTED", "IOT_TYPE", "CLUSTER_NAME", "STATUS"],
+ );
+ checked(&tables)?;
+ if tables.rows.len() != 1 {
+ return Err("The ordinary table identity could not be verified".into());
+ }
+ let table = &tables.rows[0];
+ if tables.yes_no(table, "TEMPORARY") != Some(false)
+ || tables.yes_no(table, "NESTED") != Some(false)
+ || tables.value(table, "IOT_TYPE").is_some()
+ || tables.value(table, "CLUSTER_NAME").is_some()
+ || tables.text(table, "STATUS").as_deref() != Some("VALID")
+ {
+ return Err("Temporary, nested, clustered, index-organized or unusable tables need external preparation".into());
+ }
+ let mut read_only = tables.yes_no(table, "READ_ONLY");
+ let native_definition = if dialect == Dialect::OceanBase {
+ if tables.yes_no(table, "EXTERNAL") != Some(false) {
+ return Err("The native table must have a verified non-external state".into());
+ }
+ // OB does not expose ALL_EXTERNAL_TABLES/ALL_OBJECT_TABLES. Its exact
+ // ordinary CREATE TABLE definition, not a failed/empty catalogue read,
+ // supplies the second proof and the compatibility READ_ONLY value.
+ let ddl = oceanbase_table_definition(key, run).await?;
+ let native_read_only = oceanbase_table_read_only_from_ddl(&key.owner, &key.name, &ddl)?;
+ if read_only.is_some_and(|known| known != native_read_only)
+ || read_only.is_none() && tables.value(table, "READ_ONLY").is_some()
+ {
+ return Err("The native and dictionary read-only states are inconsistent".into());
+ }
+ read_only = Some(native_read_only);
+ Some(ddl)
+ } else {
+ for catalogue in ["ALL_EXTERNAL_TABLES", "ALL_OBJECT_TABLES"] {
+ let rows = Rows::new(
+ run(format!("SELECT TABLE_NAME FROM {catalogue} WHERE {}", predicate(key))).await,
+ &["TABLE_NAME"],
+ );
+ checked(&rows)?;
+ if !rows.rows.is_empty() {
+ return Err("External and object tables need a supported ordinary-table projection".into());
+ }
+ }
+ None
+ };
+ let columns = Rows::new(
+ run(format!("SELECT * FROM ALL_TAB_COLS WHERE {} ORDER BY COLUMN_ID", predicate(key))).await,
+ &[
+ "COLUMN_NAME",
+ "COLUMN_ID",
+ "DATA_TYPE",
+ "DATA_TYPE_OWNER",
+ "DATA_LENGTH",
+ "DATA_PRECISION",
+ "DATA_SCALE",
+ "CHAR_USED",
+ "CHAR_LENGTH",
+ "HIDDEN_COLUMN",
+ "USER_GENERATED",
+ "VIRTUAL_COLUMN",
+ ],
+ );
+ checked(&columns)?;
+ let mut projection = Vec::new();
+ let mut pending = VecDeque::new();
+ for row in &columns.rows {
+ if columns.yes_no(row, "HIDDEN_COLUMN") == Some(true) && columns.yes_no(row, "USER_GENERATED") == Some(false) {
+ continue;
+ }
+ if columns.yes_no(row, "HIDDEN_COLUMN").is_none()
+ || columns.yes_no(row, "USER_GENERATED").is_none()
+ || columns.yes_no(row, "VIRTUAL_COLUMN") != Some(false)
+ {
+ return Err("Column visibility, generation or virtual-column state is not verifiable".into());
+ }
+ let path = vec![required_text(&columns, row, "COLUMN_NAME")?];
+ if let Some(owner) = columns.text(row, "DATA_TYPE_OWNER") {
+ pending.push_back((
+ path,
+ owner,
+ required_text(&columns, row, "DATA_TYPE")?,
+ Vec::<(String, String)>::new(),
+ ));
+ } else {
+ projection.push(OracleTypeDataProjection {
+ path,
+ object_null: false,
+ data_type: scalar_type(&columns, row, "DATA_")?.sql(),
+ });
+ }
+ }
+ let mut type_metadata = Vec::new();
+ while let Some((path, owner, name, mut ancestors)) = pending.pop_front() {
+ if path.len() > 4 || ancestors.contains(&(owner.clone(), name.clone())) {
+ return Err("Recursive or deeply nested UDT values need explicit external scalar preparation".into());
+ }
+ ancestors.push((owner.clone(), name.clone()));
+ let types = Rows::new(run(format!("SELECT TYPECODE, ATTRIBUTES, FINAL, INCOMPLETE, SUPERTYPE_NAME FROM ALL_TYPES WHERE OWNER={} AND TYPE_NAME={}", sql_string(&owner), sql_string(&name))).await, &["TYPECODE", "ATTRIBUTES", "FINAL", "INCOMPLETE", "SUPERTYPE_NAME"]);
+ checked(&types)?;
+ if types.rows.len() != 1
+ || types.text(&types.rows[0], "TYPECODE").as_deref() != Some("OBJECT")
+ || types.yes_no(&types.rows[0], "FINAL") != Some(true)
+ || types.yes_no(&types.rows[0], "INCOMPLETE") != Some(false)
+ || types.value(&types.rows[0], "SUPERTYPE_NAME").is_some()
+ {
+ return Err(
+ "Only complete final, non-inherited object attributes have a deterministic protected scalar projection"
+ .into(),
+ );
+ }
+ let attrs = Rows::new(run(format!("SELECT ATTR_NAME, ATTR_NO, ATTR_TYPE_MOD, ATTR_TYPE_OWNER AS DATA_TYPE_OWNER, ATTR_TYPE_NAME AS DATA_TYPE, LENGTH AS DATA_LENGTH, PRECISION AS DATA_PRECISION, SCALE AS DATA_SCALE, CHAR_USED, LENGTH AS CHAR_LENGTH FROM ALL_TYPE_ATTRS WHERE OWNER={} AND TYPE_NAME={} ORDER BY ATTR_NO", sql_string(&owner), sql_string(&name))).await, &["ATTR_NAME", "ATTR_NO", "ATTR_TYPE_MOD", "DATA_TYPE_OWNER", "DATA_TYPE", "DATA_LENGTH", "DATA_PRECISION", "DATA_SCALE", "CHAR_USED", "CHAR_LENGTH"]);
+ checked(&attrs)?;
+ if types.text(&types.rows[0], "ATTRIBUTES").and_then(|s| s.parse::<usize>().ok()) != Some(attrs.rows.len())
+ || attrs.rows.is_empty()
+ {
+ return Err("The complete object attribute list could not be verified".into());
+ }
+ projection.push(OracleTypeDataProjection {
+ path: path.clone(),
+ object_null: true,
+ data_type: "NUMBER(1,0)".into(),
+ });
+ for (index, row) in attrs.rows.iter().enumerate() {
+ if attrs.value(row, "ATTR_TYPE_MOD").is_some()
+ || attrs.text(row, "ATTR_NO").and_then(|s| s.parse::<usize>().ok()) != Some(index + 1)
+ {
+ return Err("REF, pointer or unordered object attributes need external preparation".into());
+ }
+ let mut field_path = path.clone();
+ field_path.push(required_text(&attrs, row, "ATTR_NAME")?);
+ if let Some(attr_owner) = attrs.text(row, "DATA_TYPE_OWNER") {
+ pending.push_back((
+ field_path,
+ attr_owner,
+ required_text(&attrs, row, "DATA_TYPE")?,
+ ancestors.clone(),
+ ));
+ } else {
+ if attrs.text(row, "CHAR_USED").as_deref() == Some("C") {
+ return Err("Object character-length metadata needs an explicit verified scalar preparation".into());
+ }
+ projection.push(OracleTypeDataProjection {
+ path: field_path,
+ object_null: false,
+ data_type: scalar_type(&attrs, row, "DATA_")?.sql(),
+ });
+ }
+ }
+ type_metadata.push(json!([owner, name, raw_metadata(&types), raw_metadata(&attrs)]));
+ if projection.len() + pending.len() > MAX_FIELDS {
+ return Err("The protected projection exceeds 128 scalar fields".into());
+ }
+ }
+ if projection.is_empty() || projection.len() > MAX_FIELDS || projection.iter().any(|field| field.path.len() > 4) {
+ return Err("A complete protected scalar projection of 1–128 fields is required".into());
+ }
+ let grants = Rows::new(
+ run(format!(
+ "SELECT * FROM ALL_TAB_PRIVS WHERE TABLE_SCHEMA={} AND TABLE_NAME={}",
+ sql_string(&key.owner),
+ sql_string(&key.name)
+ ))
+ .await,
+ &["TABLE_NAME", "GRANTEE", "PRIVILEGE", "GRANTOR", "GRANTABLE"],
+ );
+ checked(&grants)?;
+ // Do not serialize statistics such as NUM_ROWS/LAST_ANALYZED into identity.
+ let table_identity =
+ ["TEMPORARY", "NESTED", "IOT_TYPE", "CLUSTER_NAME", "STATUS", "READ_ONLY", "PARTITIONED", "TABLESPACE_NAME"]
+ .map(|name| (name, tables.value(table, name).cloned()));
+ let column_identity: Vec<_> = columns
+ .rows
+ .iter()
+ .map(|row| {
+ [
+ "COLUMN_NAME",
+ "COLUMN_ID",
+ "DATA_TYPE",
+ "DATA_TYPE_OWNER",
+ "DATA_LENGTH",
+ "DATA_PRECISION",
+ "DATA_SCALE",
+ "CHAR_USED",
+ "CHAR_LENGTH",
+ "HIDDEN_COLUMN",
+ "USER_GENERATED",
+ "VIRTUAL_COLUMN",
+ "NULLABLE",
+ "DATA_DEFAULT",
+ "DEFAULT_ON_NULL",
+ "IDENTITY_COLUMN",
+ "COLLATION",
+ ]
+ .map(|name| (name, columns.value(row, name).cloned()))
+ })
+ .collect();
+ let mut structure =
+ vec![json!(table_identity), json!(column_identity), raw_metadata(&grants), json!(type_metadata)];
+ if let Some(ddl) = native_definition {
+ structure.push(json!(["oceanbase_native_table_definition", ddl]));
+ }
+ let structure = serde_json::to_string(&structure).map_err(|e| e.to_string())?;
+ Ok(OracleTypeDataRelation { relation: key.clone(), object_id, read_only, structure, projection })
+}
+
+struct DataSet {
+ baseline: OracleTypeDataBaseline,
+ values: Vec<Vec<Option<String>>>,
+ types: Vec<ScalarType>,
+}
+fn frame(output: &mut Vec<u8>, bytes: &[u8]) {
+ output.extend_from_slice(&(bytes.len() as u64).to_be_bytes());
+ output.extend_from_slice(bytes);
+}
+fn encode_row(values: &[Option<String>], types: &[ScalarType]) -> Vec<u8> {
+ let mut output = Vec::new();
+ for (value, ty) in values.iter().zip(types) {
+ frame(&mut output, ty.family().as_bytes());
+ match value {
+ None => output.push(0),
+ Some(value) => {
+ output.push(1);
+ frame(&mut output, value.as_bytes());
+ }
+ }
+ }
+ output
+}
+fn digest(mut rows: Vec<Vec<u8>>, types: &[ScalarType], include_dimensions: bool) -> String {
+ rows.sort();
+ let mut hasher = Sha256::new();
+ hasher.update(b"DBX-TYPE-SCALAR-MULTISET-v1");
+ for ty in types {
+ let tag = if include_dimensions { ty.sql() } else { ty.family().into() };
+ hasher.update((tag.len() as u64).to_be_bytes());
+ hasher.update(tag.as_bytes());
+ }
+ hasher.update((rows.len() as u64).to_be_bytes());
+ for row in rows {
+ hasher.update((row.len() as u64).to_be_bytes());
+ hasher.update(row);
+ }
+ format!("{:x}", hasher.finalize())
+}
+
+/// Canonical arbitrary-precision decimal, without a floating-point roundtrip.
+fn decimal(text: &str) -> Result<String, String> {
+ let text = text.trim();
+ let (negative, text) = if let Some(value) = text.strip_prefix('-') {
+ (true, value)
+ } else {
+ (false, text.strip_prefix('+').unwrap_or(text))
+ };
+ let (mantissa, exponent) = text
+ .split_once(['E', 'e'])
+ .map_or(Ok((text, 0)), |(m, e)| e.parse::<i32>().map(|e| (m, e)).map_err(|_| "Invalid decimal exponent"))?;
+ let (integer, fraction) = mantissa.split_once('.').unwrap_or((mantissa, ""));
+ if integer.is_empty() && fraction.is_empty()
+ || !integer.bytes().chain(fraction.bytes()).all(|c| c.is_ascii_digit())
+ || exponent.unsigned_abs() > 256
+ {
+ return Err("A numeric value was not read as a complete exact decimal string".into());
+ }
+ let combined = format!("{integer}{fraction}");
+ let significant = combined.trim_start_matches('0');
+ if significant.is_empty() {
+ return Ok("0".into());
+ }
+ let trimmed = significant.trim_end_matches('0');
+ let power = exponent - fraction.len() as i32 + (significant.len() - trimmed.len()) as i32;
+ Ok(format!("{}{trimmed}e{power}", if negative { "-" } else { "" }))
+}
+
+async fn read_data<F, Fut>(dialect: Dialect, relation: OracleTypeDataRelation, run: &mut F) -> Result<DataSet, String>
+where
+ F: FnMut(String) -> Fut,
+ Fut: Future<Output = Result<db::QueryResult, String>>,
+{
+ let types: Vec<_> =
+ relation.projection.iter().map(|field| ScalarType::parse(&field.data_type)).collect::<Result<_, _>>()?;
+ let expression = |field: &OracleTypeDataProjection, ty: &ScalarType| {
+ let path = format!("T.{}", field.path.iter().map(|p| quote(p)).collect::<Vec<_>>().join("."));
+ if field.object_null {
+ return format!("CASE WHEN {path} IS NULL THEN 1 ELSE 0 END");
+ }
+ match ty.family() {
+ "decimal" if dialect == Dialect::OceanBase => {
+ format!("TO_CHAR({path}, 'TM9', 'NLS_NUMERIC_CHARACTERS=.,')")
+ }
+ "decimal" if dialect != Dialect::Dameng => {
+ format!("TO_CHAR({path}, 'TM9', 'NLS_NUMERIC_CHARACTERS=''.,''')")
+ }
+ "decimal" => format!("TO_CHAR({path})"),
+ "date" if dialect == Dialect::Dameng => format!("TO_CHAR({path}, 'SYYYY-MM-DD\"T\"HH24:MI:SS')"),
+ "timestamp" if dialect == Dialect::Dameng => format!("TO_CHAR({path}, 'SYYYY-MM-DD\"T\"HH24:MI:SS.FF9')"),
+ "date" => format!("TO_CHAR({path}, 'SYYYY-MM-DD\"T\"HH24:MI:SS', 'NLS_CALENDAR=GREGORIAN')"),
+ "timestamp" => format!("TO_CHAR({path}, 'SYYYY-MM-DD\"T\"HH24:MI:SS.FF9', 'NLS_CALENDAR=GREGORIAN')"),
+ "raw" => format!("RAWTOHEX({path})"),
+ _ => path,
+ }
+ };
+ let selected = relation
+ .projection
+ .iter()
+ .zip(&types)
+ .enumerate()
+ .map(|(i, (field, ty))| format!("{} AS \"C{i}\"", expression(field, ty)))
+ .collect::<Vec<_>>()
+ .join(", ");
+ let count_sql = format!("SELECT TO_CHAR(COUNT(*)) AS ROW_COUNT FROM {}", qualified(&relation.relation));
+ let count = |rows: &Rows| -> Result<usize, String> {
+ checked(rows)?;
+ if rows.rows.len() != 1 {
+ return Err("The full relation count is unavailable".into());
+ }
+ required_text(rows, &rows.rows[0], "ROW_COUNT")?
+ .parse()
+ .map_err(|_| "The relation count is not an exact integer".into())
+ };
+ let before_count = count(&Rows::new(run(count_sql.clone()).await, &["ROW_COUNT"]))?;
+ if before_count > MAX_ROWS {
+ return Err("The complete projection exceeds the 10000-row verification budget; partition the migration before registering its baseline".into());
+ }
+ let row_capacity: usize = types
+ .iter()
+ .zip(&relation.projection)
+ .map(|(ty, field)| {
+ let value_bytes = if field.object_null {
+ 1
+ } else {
+ match ty.family() {
+ "text" => ty.size.unwrap_or(32767) as usize * 4,
+ "raw" => ty.size.unwrap_or(32767) as usize * 2,
+ "decimal" => 256,
+ _ => 64,
+ }
+ };
+ value_bytes + 64
+ })
+ .sum();
+ // Bound transport allocation before fetching, including one sentinel row if
+ // a concurrent insert occurs after COUNT. No lossy paging is needed.
+ if row_capacity.saturating_mul(before_count + 1) > MAX_BYTES {
+ return Err("Declared scalar widths and row count exceed the safe 8 MiB read budget. Reduce the migration scope before registering a complete baseline".into());
+ }
+ let aliases: Vec<_> = (0..types.len()).map(|i| format!("C{i}")).collect();
+ let required: Vec<_> = aliases.iter().map(String::as_str).collect();
+ let rows = Rows::new(
+ run(format!("SELECT {selected} FROM {} T WHERE ROWNUM <= {}", qualified(&relation.relation), before_count + 1))
+ .await,
+ &required,
+ );
+ checked(&rows)?;
+ if rows.rows.len() != before_count || count(&Rows::new(run(count_sql).await, &["ROW_COUNT"]))? != before_count {
+ return Err("The relation changed or the driver did not return the complete projection".into());
+ }
+ let mut values = Vec::new();
+ let mut bytes = 0;
+ for row in &rows.rows {
+ let mut encoded = Vec::new();
+ for (i, ty) in types.iter().enumerate() {
+ let value = match rows.value(row, &aliases[i]) {
+ None => None,
+ Some(Value::String(value)) => {
+ Some(if ty.family() == "decimal" { decimal(value)? } else { value.clone() })
+ }
+ // Only our object-null CASE is allowed to cross a numeric driver cell.
+ Some(Value::Number(n))
+ if relation.projection[i].object_null && (n.as_u64() == Some(0) || n.as_u64() == Some(1)) =>
+ {
+ Some(decimal(&n.to_string())?)
+ }
+ _ => return Err("A value was not transported as a complete lossless scalar string".into()),
+ };
+ bytes += value.as_ref().map_or(1, |value| value.len() + 16);
+ if bytes > MAX_BYTES {
+ return Err("The complete projection exceeds the 8 MiB verification budget; no complete fingerprint was created".into());
+ }
+ encoded.push(value);
+ }
+ values.push(encoded);
+ }
+ let encoded: Vec<_> = values.iter().map(|row| encode_row(row, &types)).collect();
+ let fingerprint = digest(encoded, &types, true);
+ if describe(dialect, &relation.relation, run).await? != relation {
+ return Err(
+ "The relation identity, definition, grants or read-only state changed during the complete read".into()
+ );
+ }
+ Ok(DataSet {
+ baseline: OracleTypeDataBaseline { relation, row_count: values.len() as u32, fingerprint },
+ values,
+ types,
+ })
+}
+
+fn projected_digest(data: &DataSet, indexes: &[usize]) -> String {
+ let types: Vec<_> = indexes.iter().map(|&i| data.types[i].clone()).collect();
+ digest(
+ data.values
+ .iter()
+ .map(|row| encode_row(&indexes.iter().map(|&i| row[i].clone()).collect::<Vec<_>>(), &types))
+ .collect(),
+ &types,
+ false,
+ )
+}
+fn projection_indexes(data: &DataSet, paths: &[(Vec<String>, bool)], require_all: bool) -> Result<Vec<usize>, String> {
+ let indexes: Vec<_> = paths
+ .iter()
+ .map(|(path, object_null)| {
+ data.baseline
+ .relation
+ .projection
+ .iter()
+ .position(|field| &field.path == path && field.object_null == *object_null)
+ .ok_or("A mapped field is absent from the complete protected projection")
+ })
+ .collect::<Result<_, _>>()?;
+ if indexes.iter().collect::<HashSet<_>>().len() != indexes.len() || require_all && indexes.len() != data.types.len()
+ {
+ return Err("Map every protected field exactly once; fields cannot be omitted or duplicated".into());
+ }
+ Ok(indexes)
+}
+fn compare(left: &DataSet, li: &[usize], right: &DataSet, ri: &[usize]) -> Result<(), String> {
+ if left.baseline.row_count != right.baseline.row_count || projected_digest(left, li) != projected_digest(right, ri)
+ {
+ return Err("The full typed values, NULLs or duplicate-row multiplicities do not match".into());
+ }
+ Ok(())
+}
+fn scalar_relation(relation: &OracleTypeDataRelation) -> Result<(), String> {
+ if relation.projection.iter().any(|field| field.object_null || field.path.len() != 1) {
+ Err("OLD and EXPECTED must contain only ordinary scalar columns".into())
+ } else {
+ Ok(())
+ }
+}
+fn same_baseline(expected: &OracleTypeDataBaseline, actual: &OracleTypeDataBaseline) -> Result<(), String> {
+ if expected != actual {
+ Err("A registered baseline changed identity, structure, grants, read-only state, values or multiplicities. Keep the original manifest; do not replace its baseline".into())
+ } else {
+ Ok(())
+ }
+}
+fn validate_mapping(mapping: &OracleTypeDataMappingInput) -> Result<(), String> {
+ if mapping.id.is_empty()
+ || mapping.fields.is_empty()
+ || mapping.fields.len() > MAX_FIELDS
+ || mapping.old == mapping.expected
+ || [mapping.source.clone(), mapping.target.clone()]
+ .iter()
+ .any(|key| *key == mapping.old || *key == mapping.expected)
+ {
+ return Err("Register distinct permanent OLD/EXPECTED tables and a complete bounded field mapping".into());
+ }
+ Ok(())
+}
+async fn baselines<F, Fut>(
+ dialect: Dialect,
+ mapping: &OracleTypeDataMappingInput,
+ run: &mut F,
+) -> Result<(DataSet, DataSet), String>
+where
+ F: FnMut(String) -> Fut,
+ Fut: Future<Output = Result<db::QueryResult, String>>,
+{
+ validate_mapping(mapping)?;
+ let mut read = Vec::new();
+ for key in [&mapping.old, &mapping.expected] {
+ let relation = describe(dialect, key, run).await?;
+ scalar_relation(&relation)?;
+ if relation.read_only != Some(true) {
+ return Err(format!("{} must have a verified native READ ONLY state. Commit and protect it in the SQL editor, then reread; an unknown adapter state is not read-only", qualified(key)));
+ }
+ read.push(read_data(dialect, relation, run).await?);
+ }
+ let expected = read.pop().unwrap();
+ let old = read.pop().unwrap();
+ let old_indexes = projection_indexes(
+ &old,
+ &mapping.fields.iter().map(|f| (vec![f.old_column.clone()], false)).collect::<Vec<_>>(),
+ true,
+ )?;
+ let expected_indexes = projection_indexes(
+ &expected,
+ &mapping.fields.iter().map(|f| (vec![f.expected_column.clone()], false)).collect::<Vec<_>>(),
+ true,
+ )?;
+ if old.baseline.row_count != expected.baseline.row_count {
+ return Err("OLD to EXPECTED must retain the full row count/multiplicity; aggregation and row deletion are not part of this migration".into());
+ }
+ let unchanged: Vec<_> = mapping.fields.iter().enumerate().filter_map(|(i, f)| f.unchanged.then_some(i)).collect();
+ compare(
+ &old,
+ &unchanged.iter().map(|&i| old_indexes[i]).collect::<Vec<_>>(),
+ &expected,
+ &unchanged.iter().map(|&i| expected_indexes[i]).collect::<Vec<_>>(),
+ )?;
+ Ok((old, expected))
+}
+
+pub(super) async fn read<F, Fut>(
+ dialect: Dialect,
+ input: OracleTypeDataRequest,
+ mut run: F,
+) -> Result<OracleTypeDataResult, String>
+where
+ F: FnMut(String) -> Fut,
+ Fut: Future<Output = Result<db::QueryResult, String>>,
+{
+ let mut result = OracleTypeDataResult { relation: None, manifest: None, insert_sql: None };
+ if input.action == "describe" {
+ result.relation =
+ Some(describe(dialect, &input.relation.ok_or("Relation identity is required")?, &mut run).await?);
+ return Ok(result);
+ }
+ if input.action == "register" {
+ let mapping = input.mapping.ok_or("The permanent mapping is required")?;
+ let (old, expected) = baselines(dialect, &mapping, &mut run).await?;
+ let relation = describe(dialect, &mapping.source, &mut run).await?;
+ let original = read_data(dialect, relation, &mut run).await?;
+ let source_indexes = projection_indexes(
+ &original,
+ &mapping.fields.iter().map(|f| (f.source_path.clone(), f.object_null)).collect::<Vec<_>>(),
+ true,
+ )?;
+ let old_indexes = projection_indexes(
+ &old,
+ &mapping.fields.iter().map(|f| (vec![f.old_column.clone()], false)).collect::<Vec<_>>(),
+ true,
+ )?;
+ compare(&original, &source_indexes, &old, &old_indexes)?;
+ result.manifest = Some(OracleTypeDataManifest {
+ mapping,
+ original: original.baseline,
+ old: old.baseline,
+ expected: expected.baseline,
+ prepared_target: None,
+ verified_target: None,
+ });
+ return Ok(result);
+ }
+ let mut manifest = input.manifest.ok_or("The original persisted data manifest is required")?;
+ let mapping = &manifest.mapping;
+ let (old, expected) = baselines(dialect, mapping, &mut run).await?;
+ same_baseline(&manifest.old, &old.baseline)?;
+ same_baseline(&manifest.expected, &expected.baseline)?;
+ if manifest.original.row_count != old.baseline.row_count {
+ return Err("The original baseline count is inconsistent".into());
+ }
+ let relation = describe(dialect, &mapping.target, &mut run).await?;
+ if input.action == "validate_insert" {
+ scalar_relation(&relation)?;
+ let actual = read_data(dialect, relation.clone(), &mut run).await?;
+ if actual.baseline.row_count != 0 || manifest.verified_target.is_some() {
+ return Err(
+ "INSERT is only available for the registered, still-empty scalar target before any verified insertion"
+ .into(),
+ );
+ }
+ if let Some(prepared) = &manifest.prepared_target {
+ same_baseline(prepared, &actual.baseline)?;
+ }
+ validate_insert_target(dialect, &relation, &mut run).await?;
+ let columns = |relation: &OracleTypeDataRelation| -> Result<Vec<ScalarColumn>, String> {
+ relation
+ .projection
+ .iter()
+ .map(|field| {
+ Ok(ScalarColumn { name: field.path[0].clone(), data_type: ScalarType::parse(&field.data_type)? })
+ })
+ .collect()
+ };
+ result.insert_sql = Some(validate_scalar_insert(
+ &input.sql.ok_or("Supply the single bounded INSERT SELECT")?,
+ (&mapping.target.owner, &mapping.target.name),
+ (&mapping.expected.owner, &mapping.expected.name),
+ &columns(&relation)?,
+ &columns(&expected.baseline.relation)?,
+ )?);
+ manifest.prepared_target = Some(actual.baseline);
+ } else if input.action == "verify" {
+ let actual = read_data(dialect, relation, &mut run).await?;
+ let target_indexes = projection_indexes(
+ &actual,
+ &mapping.fields.iter().map(|f| (f.target_path.clone(), f.target_object_null)).collect::<Vec<_>>(),
+ true,
+ )?;
+ let expected_indexes = projection_indexes(
+ &expected,
+ &mapping.fields.iter().map(|f| (vec![f.expected_column.clone()], false)).collect::<Vec<_>>(),
+ true,
+ )?;
+ compare(&actual, &target_indexes, &expected, &expected_indexes)?;
+ if let Some(prepared) = &manifest.prepared_target {
+ if prepared.relation != actual.baseline.relation {
+ return Err("The prepared INSERT target changed identity or structure".into());
+ }
+ }
+ if let Some(verified) = &manifest.verified_target {
+ same_baseline(verified, &actual.baseline)?;
+ }
+ manifest.verified_target = Some(actual.baseline);
+ } else {
+ return Err("Unknown TYPE data verification action".into());
+ }
+ result.manifest = Some(manifest);
+ Ok(result)
+}
+
+async fn validate_insert_target<F, Fut>(
+ dialect: Dialect,
+ relation: &OracleTypeDataRelation,
+ run: &mut F,
+) -> Result<(), String>
+where
+ F: FnMut(String) -> Fut,
+ Fut: Future<Output = Result<db::QueryResult, String>>,
+{
+ if relation.read_only != Some(false) {
+ return Err("The scalar INSERT target must have a verified READ WRITE state".into());
+ }
+ let key = &relation.relation;
+ let native_plain_columns = if dialect == Dialect::OceanBase {
+ let ddl = oceanbase_table_definition(key, run).await?;
+ let columns = oceanbase_scalar_insert_columns(&key.owner, &key.name, &ddl)?;
+ if columns != relation.projection.iter().map(|field| field.path[0].clone()).collect::<Vec<_>>() {
+ return Err("The complete native scalar columns differ from the registered projection".into());
+ }
+ true
+ } else {
+ false
+ };
+ let columns = Rows::new(run(format!("SELECT COLUMN_NAME, DATA_DEFAULT, VIRTUAL_COLUMN, HIDDEN_COLUMN, IDENTITY_COLUMN, DEFAULT_ON_NULL FROM ALL_TAB_COLS WHERE {}", predicate(key))).await, &["COLUMN_NAME", "DATA_DEFAULT", "VIRTUAL_COLUMN", "HIDDEN_COLUMN", "IDENTITY_COLUMN", "DEFAULT_ON_NULL"]);
+ checked(&columns)?;
+ if columns.rows.len() != relation.projection.len()
+ || columns.rows.iter().any(|row| {
+ columns.value(row, "DATA_DEFAULT").is_some()
+ || ["VIRTUAL_COLUMN", "HIDDEN_COLUMN"].iter().any(|flag| columns.yes_no(row, flag) != Some(false))
+ || ["IDENTITY_COLUMN", "DEFAULT_ON_NULL"].iter().any(|flag| match columns.yes_no(row, flag) {
+ Some(false) => false,
+ None if native_plain_columns && columns.value(row, flag).is_none() => false,
+ _ => true,
+ })
+ })
+ {
+ return Err("The target has default, virtual, hidden or identity execution semantics; prepare it in the SQL editor instead".into());
+ }
+ for (sql, required, label) in [
+ (
+ format!(
+ "SELECT TRIGGER_NAME FROM ALL_TRIGGERS WHERE TABLE_OWNER={} AND TABLE_NAME={}",
+ sql_string(&key.owner),
+ sql_string(&key.name)
+ ),
+ "TRIGGER_NAME",
+ "triggers",
+ ),
+ (
+ format!(
+ "SELECT POLICY_NAME FROM ALL_POLICIES WHERE OBJECT_OWNER={} AND OBJECT_NAME={}",
+ sql_string(&key.owner),
+ sql_string(&key.name)
+ ),
+ "POLICY_NAME",
+ "row-security policies",
+ ),
+ ] {
+ let rows = Rows::new(run(sql).await, &[required]);
+ checked(&rows)?;
+ if !rows.rows.is_empty() {
+ return Err(format!("The target has {label}; use the SQL editor and return for verification"));
+ }
+ }
+ let indexes = Rows::new(
+ run(format!(
+ "SELECT INDEX_TYPE FROM ALL_INDEXES WHERE TABLE_OWNER={} AND TABLE_NAME={}",
+ sql_string(&key.owner),
+ sql_string(&key.name)
+ ))
+ .await,
+ &["INDEX_TYPE"],
+ );
+ checked(&indexes)?;
+ if indexes
+ .rows
+ .iter()
+ .any(|row| !matches!(indexes.text(row, "INDEX_TYPE").as_deref(), Some("NORMAL" | "NORMAL/REV" | "BITMAP")))
+ {
+ return Err("The target has an unknown, function-based or domain index".into());
+ }
+ let condition =
+ if dialect == Dialect::OceanBase { "SEARCH_CONDITION AS SEARCH_CONDITION_VC" } else { "SEARCH_CONDITION_VC" };
+ let constraints = Rows::new(
+ run(format!("SELECT CONSTRAINT_TYPE, {condition} FROM ALL_CONSTRAINTS WHERE {}", predicate(key))).await,
+ &["CONSTRAINT_TYPE", "SEARCH_CONDITION_VC"],
+ );
+ checked(&constraints)?;
+ for row in &constraints.rows {
+ match constraints.text(row, "CONSTRAINT_TYPE").as_deref() {
+ Some("P" | "U" | "R") => (),
+ Some("C")
+ if relation.projection.iter().any(|field| {
+ constraints.text(row, "SEARCH_CONDITION_VC").as_deref()
+ == Some(format!("{} IS NOT NULL", quote(&field.path[0])).as_str())
+ }) => {}
+ _ => return Err("A target constraint is not a verified key or simple NOT NULL check".into()),
+ }
+ }
+ Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use std::collections::BTreeMap;
+ #[derive(Clone)]
+ struct Table {
+ id: String,
+ readonly: Option<bool>,
+ rows: Vec<Vec<Value>>,
+ }
+ #[derive(Clone)]
+ struct Fixture {
+ tables: BTreeMap<String, Table>,
+ fault: Option<&'static str>,
+ }
+ fn answer(columns: &[&str], rows: Vec<Vec<Value>>) -> db::QueryResult {
+ serde_json::from_value(json!({ "columns": columns, "rows": rows, "affected_rows": 0, "execution_time_ms": 0 }))
+ .unwrap()
+ }
+ impl Fixture {
+ fn new() -> Self {
+ let rows = vec![
+ vec![json!("90071992547409931234567890.1200"), json!("A ")],
+ vec![json!("90071992547409931234567890.1200"), json!("A ")],
+ vec![Value::Null, Value::Null],
+ ];
+ Self {
+ tables: ["SRC", "OLD", "EXPECTED", "RESULT"]
+ .into_iter()
+ .enumerate()
+ .map(|(i, name)| {
+ (
+ name.into(),
+ Table {
+ id: format!("900719925474099{}", i + 3),
+ readonly: Some(name == "OLD" || name == "EXPECTED"),
+ rows: if name == "RESULT" { vec![] } else { rows.clone() },
+ },
+ )
+ })
+ .collect(),
+ fault: None,
+ }
+ }
+ fn query(&self, sql: String) -> Result<db::QueryResult, String> {
+ let name = ["SRC", "OLD", "EXPECTED", "RESULT"]
+ .into_iter()
+ .find(|name| sql.contains(&format!("'{name}'")) || sql.contains(&format!("\"APP\".\"{name}\"")))
+ .ok_or_else(|| format!("Unexpected fixture query: {sql}"))?;
+ let table = self.tables.get(name).ok_or("Missing table")?;
+ if sql.contains("FROM ALL_OBJECTS") {
+ return Ok(answer(
+ &["OBJECT_ID", "OBJECT_TYPE", "TEMPORARY"],
+ vec![vec![json!(table.id), json!("TABLE"), json!("N")]],
+ ));
+ }
+ if sql.contains("FROM ALL_TABLES") {
+ return Ok(answer(
+ &[
+ "OWNER",
+ "TABLE_NAME",
+ "TEMPORARY",
+ "NESTED",
+ "IOT_TYPE",
+ "CLUSTER_NAME",
+ "STATUS",
+ "READ_ONLY",
+ "PARTITIONED",
+ "TABLESPACE_NAME",
+ "EXTERNAL",
+ ],
+ vec![vec![
+ json!("APP"),
+ json!(name),
+ json!("N"),
+ json!("NO"),
+ Value::Null,
+ Value::Null,
+ json!("VALID"),
+ table.readonly.map(|b| json!(if b { "YES" } else { "NO" })).unwrap_or(Value::Null),
+ json!("NO"),
+ json!("USERS"),
+ json!("NO"),
+ ]],
+ ));
+ }
+ if sql.contains("FROM ALL_EXTERNAL_TABLES") || sql.contains("FROM ALL_OBJECT_TABLES") {
+ return Ok(answer(&["TABLE_NAME"], vec![]));
+ }
+ if sql.contains("FROM ALL_TAB_COLS") {
+ let columns = [
+ "COLUMN_NAME",
+ "COLUMN_ID",
+ "DATA_TYPE",
+ "DATA_TYPE_OWNER",
+ "DATA_LENGTH",
+ "DATA_PRECISION",
+ "DATA_SCALE",
+ "CHAR_USED",
+ "CHAR_LENGTH",
+ "HIDDEN_COLUMN",
+ "USER_GENERATED",
+ "VIRTUAL_COLUMN",
+ "IDENTITY_COLUMN",
+ "DEFAULT_ON_NULL",
+ "DATA_DEFAULT",
+ "NULLABLE",
+ ];
+ return Ok(answer(
+ &columns,
+ vec![
+ vec![
+ json!("ID"),
+ json!(1),
+ json!("NUMBER"),
+ Value::Null,
+ json!(22),
+ json!(38),
+ json!(4),
+ Value::Null,
+ json!(0),
+ json!("NO"),
+ json!("YES"),
+ json!("NO"),
+ json!("NO"),
+ json!("NO"),
+ Value::Null,
+ json!("Y"),
+ ],
+ vec![
+ json!("LABEL"),
+ json!(2),
+ json!("VARCHAR2"),
+ Value::Null,
+ json!(80),
+ Value::Null,
+ Value::Null,
+ json!("B"),
+ json!(80),
+ json!("NO"),
+ json!("YES"),
+ json!("NO"),
+ json!("NO"),
+ json!("NO"),
+ Value::Null,
+ json!("Y"),
+ ],
+ ],
+ ));
+ }
+ if sql.contains("FROM ALL_TAB_PRIVS") {
+ return Ok(answer(&["TABLE_NAME", "GRANTEE", "PRIVILEGE", "GRANTOR", "GRANTABLE"], vec![]));
+ }
+ if sql.contains("FROM ALL_TRIGGERS") {
+ return Ok(answer(
+ &["TRIGGER_NAME"],
+ if self.fault == Some("trigger") && name == "RESULT" {
+ vec![vec![json!("HIDDEN_WRITE")]]
+ } else {
+ vec![]
+ },
+ ));
+ }
+ if sql.contains("FROM ALL_POLICIES") {
+ return Ok(answer(&["POLICY_NAME"], vec![]));
+ }
+ if sql.contains("FROM ALL_INDEXES") {
+ return Ok(answer(
+ &["INDEX_TYPE"],
+ if self.fault == Some("function-index") {
+ vec![vec![json!("FUNCTION-BASED NORMAL")]]
+ } else {
+ vec![]
+ },
+ ));
+ }
+ if sql.contains("FROM ALL_CONSTRAINTS") {
+ return Ok(answer(&["CONSTRAINT_TYPE", "SEARCH_CONDITION_VC"], vec![]));
+ }
+ if sql.starts_with("SELECT TO_CHAR(COUNT(*))") {
+ return Ok(answer(&["ROW_COUNT"], vec![vec![json!(table.rows.len().to_string())]]));
+ }
+ if sql.starts_with("SELECT TO_CHAR(T.") {
+ let mut rows = answer(&["C0", "C1"], table.rows.clone());
+ if self.fault == Some("truncated") {
+ rows.truncated = true;
+ }
+ if self.fault == Some("has-more") {
+ rows.has_more = true;
+ }
+ if self.fault == Some("lossy-number") {
+ rows.rows[0][0] = json!(9007199254740992_u64);
+ }
+ if self.fault == Some("large-cell") {
+ rows.rows[0][1] = json!({"type":"large-value", "preview":"A"});
+ }
+ if self.fault == Some("silent-limit") {
+ rows.rows.pop();
+ }
+ return Ok(rows);
+ }
+ Err(format!("Unexpected fixture query: {sql}"))
+ }
+ async fn call(
+ &self,
+ action: &str,
+ manifest: Option<OracleTypeDataManifest>,
+ sql: Option<&str>,
+ ) -> Result<OracleTypeDataResult, String> {
+ let request = OracleTypeDataRequest {
+ target: db::OracleTypeManagementTarget {
+ connection_id: "test".into(),
+ database: "db".into(),
+ owner: "APP".into(),
+ name: "ROOT".into(),
+ },
+ action: action.into(),
+ relation: None,
+ mapping: Some(mapping()),
+ manifest,
+ sql: sql.map(String::from),
+ };
+ read(Dialect::Oracle, request, |sql| std::future::ready(self.query(sql))).await
+ }
+ }
+ fn mapping() -> OracleTypeDataMappingInput {
+ let relation = |name: &str| OracleTypeDataRelationKey { owner: "APP".into(), name: name.into() };
+ OracleTypeDataMappingInput {
+ id: "mapping-original".into(),
+ source: relation("SRC"),
+ old: relation("OLD"),
+ expected: relation("EXPECTED"),
+ target: relation("RESULT"),
+ fields: ["ID", "LABEL"]
+ .map(|name| db::OracleTypeDataField {
+ source_path: vec![name.into()],
+ object_null: false,
+ old_column: name.into(),
+ expected_column: name.into(),
+ target_path: vec![name.into()],
+ target_object_null: false,
+ unchanged: true,
+ })
+ .into(),
+ }
+ }
+
+ fn oceanbase_query(fixture: &Fixture, sql: String) -> Result<db::QueryResult, String> {
+ if sql.contains("NLS_NUMERIC_CHARACTERS=''.,''") {
+ return Err("OB 4.2.5.7: invalid NLS parameter string (12702)".into());
+ }
+ if sql.contains("ALL_EXTERNAL_TABLES") || sql.contains("ALL_OBJECT_TABLES") {
+ return Err("OB 4.2.5.7: catalogue does not exist (942)".into());
+ }
+ if sql.contains("FROM ALL_CONSTRAINTS") && !sql.contains("SEARCH_CONDITION AS SEARCH_CONDITION_VC") {
+ return Err("OB 4.2.5.7: SEARCH_CONDITION_VC does not exist (904)".into());
+ }
+ if sql.contains("DBMS_METADATA.GET_DDL") {
+ let name = ["SRC", "OLD", "EXPECTED", "RESULT"]
+ .into_iter()
+ .find(|name| sql.contains(&format!("'{name}'")))
+ .unwrap();
+ assert_eq!(sql, format!("SELECT DBMS_METADATA.GET_DDL('TABLE', '{name}', 'APP') AS TABLE_DDL FROM DUAL"));
+ let read_only = fixture.tables[name].readonly.unwrap_or(name == "OLD" || name == "EXPECTED");
+ return Ok(answer(&["TABLE_DDL"], vec![vec![json!(format!("CREATE TABLE \"{name}\" (\"ID\" NUMBER(38,4), \"LABEL\" VARCHAR2(80 BYTE), PRIMARY KEY (\"ID\")) COMPRESS FOR ARCHIVE REPLICA_NUM = 1 BLOCK_SIZE = 16384 USE_BLOOM_FILTER = FALSE TABLET_SIZE = 134217728 PCTFREE = 0{}", if read_only { " READ ONLY" } else { "" }))]]));
+ }
+ let mut response = fixture.query(sql.clone())?;
+ if sql.contains("FROM ALL_TAB_COLS") {
+ for flag in ["IDENTITY_COLUMN", "DEFAULT_ON_NULL"] {
+ let index = response.columns.iter().position(|name| name == flag).unwrap();
+ for row in &mut response.rows {
+ row[index] = Value::Null;
+ }
+ }
+ }
+ Ok(response)
+ }
+
+ #[tokio::test]
+ async fn oceanbase_null_dictionary_readonly_uses_complete_bound_native_ddl() {
+ let mut fixture = Fixture::new();
+ for table in fixture.tables.values_mut() {
+ table.readonly = None;
+ }
+ let input = OracleTypeDataRequest {
+ target: db::OracleTypeManagementTarget {
+ connection_id: "test".into(),
+ database: "db".into(),
+ owner: "APP".into(),
+ name: "ROOT".into(),
+ },
+ action: "register".into(),
+ relation: None,
+ mapping: Some(mapping()),
+ manifest: None,
+ sql: None,
+ };
+ let run = |sql: String| oceanbase_query(&fixture, sql);
+ let result = read(Dialect::OceanBase, input, |sql| std::future::ready(run(sql))).await;
+ assert!(result.is_ok(), "The bound native READ ONLY definition must be usable: {result:?}");
+ let manifest = result.unwrap().manifest.unwrap();
+ assert_eq!(manifest.old.relation.read_only, Some(true));
+ assert_eq!(manifest.expected.relation.read_only, Some(true));
+ assert_eq!(manifest.original.relation.read_only, Some(false));
+ let insert = OracleTypeDataRequest {
+ target: db::OracleTypeManagementTarget {
+ connection_id: "test".into(),
+ database: "db".into(),
+ owner: "APP".into(),
+ name: "ROOT".into(),
+ },
+ action: "validate_insert".into(),
+ relation: None,
+ mapping: None,
+ manifest: Some(manifest.clone()),
+ sql: Some("INSERT INTO APP.RESULT(ID,LABEL) SELECT ID,LABEL FROM APP.EXPECTED".into()),
+ };
+ let result = read(Dialect::OceanBase, insert, |sql| std::future::ready(run(sql))).await.unwrap();
+ assert!(result.insert_sql.unwrap().starts_with("INSERT INTO \"APP\".\"RESULT\""));
+ let mut blocked = fixture.clone();
+ blocked.tables.get_mut("RESULT").unwrap().readonly = Some(true);
+ let relation = describe(Dialect::OceanBase, &manifest.mapping.target, &mut |sql| {
+ std::future::ready(oceanbase_query(&blocked, sql))
+ })
+ .await
+ .unwrap();
+ let error = validate_insert_target(Dialect::OceanBase, &relation, &mut |sql| {
+ std::future::ready(oceanbase_query(&blocked, sql))
+ })
+ .await
+ .unwrap_err();
+ assert!(error.contains("READ WRITE"));
+ }
+
+ #[tokio::test]
+ async fn oceanbase_readonly_fallback_rejects_incomplete_or_unbound_ddl() {
+ let mut fixture = Fixture::new();
+ fixture.tables.get_mut("OLD").unwrap().readonly = None;
+ let key = OracleTypeDataRelationKey { owner: "APP".into(), name: "OLD".into() };
+ for fault in [
+ "truncated",
+ "has-more",
+ "large-cell",
+ "missing",
+ "multirow",
+ "wrong-name",
+ "wrong-owner",
+ "partial",
+ "denied",
+ ] {
+ let mut run = |sql: String| {
+ let result = if sql.contains("DBMS_METADATA.GET_DDL") {
+ if fault == "denied" {
+ Err("Metadata permission denied".into())
+ } else {
+ oceanbase_query(&fixture, sql).map(|mut result| {
+ match fault {
+ "truncated" => result.truncated = true,
+ "has-more" => result.has_more = true,
+ "large-cell" => {
+ result.rows[0][0] = json!({"preview":"CREATE TABLE OLD", "truncated":true})
+ }
+ "missing" => result.rows.clear(),
+ "multirow" => result.rows.push(result.rows[0].clone()),
+ "wrong-name" => {
+ result.rows[0][0] =
+ json!(result.rows[0][0].as_str().unwrap().replace("\"OLD\"", "\"OTHER\""))
+ }
+ "wrong-owner" => {
+ result.rows[0][0] = json!(result.rows[0][0]
+ .as_str()
+ .unwrap()
+ .replace("\"OLD\"", "\"OTHER\".\"OLD\""))
+ }
+ "partial" => result.rows[0][0] = json!("CREATE TABLE OLD (ID NUMBER) READ ONLY"),
+ _ => unreachable!(),
+ }
+ result
+ })
+ }
+ } else {
+ fixture.query(sql)
+ };
+ std::future::ready(result)
+ };
+ assert!(describe(Dialect::OceanBase, &key, &mut run).await.is_err(), "{fault}");
+ }
+ for dialect in [Dialect::Oracle, Dialect::Dameng] {
+ let relation = describe(dialect, &key, &mut |sql| std::future::ready(fixture.query(sql))).await.unwrap();
+ assert_eq!(relation.read_only, None);
+ }
+ fixture.tables.get_mut("OLD").unwrap().readonly = Some(true);
+ let relation =
+ describe(Dialect::OceanBase, &key, &mut |sql| std::future::ready(oceanbase_query(&fixture, sql)))
+ .await
+ .unwrap();
+ assert_eq!(relation.read_only, Some(true));
+ }
+
+ #[tokio::test]
+ async fn oceanbase_native_definition_cannot_hide_implicit_insert_execution() {
+ let mut fixture = Fixture::new();
+ fixture.tables.get_mut("RESULT").unwrap().readonly = None;
+ let key = OracleTypeDataRelationKey { owner: "APP".into(), name: "RESULT".into() };
+ let relation =
+ describe(Dialect::OceanBase, &key, &mut |sql| std::future::ready(oceanbase_query(&fixture, sql)))
+ .await
+ .unwrap();
+ for fault in [
+ "default",
+ "identity",
+ "generated",
+ "inline-check",
+ "wrong-column",
+ "metadata-identity",
+ "metadata-on-null",
+ "metadata-unknown",
+ "hidden",
+ "virtual",
+ ] {
+ let mut run = |sql: String| {
+ let result = oceanbase_query(&fixture, sql.clone()).map(|mut response| {
+ if sql.contains("DBMS_METADATA.GET_DDL") {
+ let ddl = response.rows[0][0].as_str().unwrap();
+ response.rows[0][0] = json!(match fault {
+ "default" => ddl.replace("NUMBER(38,4)", "NUMBER(38,4) DEFAULT APP.F()"),
+ "identity" => ddl.replace("NUMBER(38,4)", "NUMBER(38,4) GENERATED BY DEFAULT AS IDENTITY"),
+ "generated" => ddl.replace("NUMBER(38,4)", "NUMBER(38,4) GENERATED ALWAYS AS (1) VIRTUAL"),
+ "inline-check" => ddl.replace("NUMBER(38,4)", "NUMBER(38,4) CHECK (APP.F(ID)=1)"),
+ "wrong-column" => ddl.replace("\"LABEL\"", "\"OTHER\""),
+ _ => ddl.into(),
+ });
+ }
+ if sql.contains("FROM ALL_TAB_COLS") {
+ let flag = match fault {
+ "metadata-identity" | "metadata-unknown" => Some("IDENTITY_COLUMN"),
+ "metadata-on-null" => Some("DEFAULT_ON_NULL"),
+ "hidden" => Some("HIDDEN_COLUMN"),
+ "virtual" => Some("VIRTUAL_COLUMN"),
+ _ => None,
+ };
+ if let Some(flag) = flag {
+ let index = response.columns.iter().position(|name| name == flag).unwrap();
+ response.rows[0][index] =
+ json!(if fault == "metadata-unknown" { "UNKNOWN" } else { "YES" });
+ }
+ }
+ response
+ });
+ std::future::ready(result)
+ };
+ assert!(validate_insert_target(Dialect::OceanBase, &relation, &mut run).await.is_err(), "{fault}");
+ }
+ for fault in ["external", "unknown-external", "object-table"] {
+ let mut run = |sql: String| {
+ let result = oceanbase_query(&fixture, sql.clone()).map(|mut response| {
+ if sql.contains("FROM ALL_TABLES") {
+ let external = response.columns.iter().position(|name| name == "EXTERNAL").unwrap();
+ response.rows[0][external] = match fault {
+ "external" => json!("YES"),
+ "unknown-external" => Value::Null,
+ _ => json!("NO"),
+ };
+ }
+ if fault == "object-table" && sql.contains("DBMS_METADATA.GET_DDL") {
+ response.rows[0][0] = json!("CREATE TABLE RESULT OF APP.OBJECT_TYPE");
+ }
+ response
+ });
+ std::future::ready(result)
+ };
+ assert!(describe(Dialect::OceanBase, &key, &mut run).await.is_err(), "{fault}");
+ }
+ }
+
+ #[tokio::test]
+ async fn oceanbase_native_readonly_change_during_full_read_is_rejected() {
+ let mut fixture = Fixture::new();
+ fixture.tables.get_mut("OLD").unwrap().readonly = None;
+ let calls = std::cell::Cell::new(0);
+ let mut run = |sql: String| {
+ let is_ddl = sql.contains("DBMS_METADATA.GET_DDL");
+ let result = oceanbase_query(&fixture, sql).map(|mut response| {
+ if is_ddl {
+ calls.set(calls.get() + 1);
+ if calls.get() > 1 {
+ response.rows[0][0] = json!(response.rows[0][0].as_str().unwrap().replace(" READ ONLY", ""));
+ }
+ }
+ response
+ });
+ std::future::ready(result)
+ };
+ let key = OracleTypeDataRelationKey { owner: "APP".into(), name: "OLD".into() };
+ let relation = describe(Dialect::OceanBase, &key, &mut run).await.unwrap();
+ let error = match read_data(Dialect::OceanBase, relation, &mut run).await {
+ Err(error) => error,
+ Ok(_) => panic!("A READ ONLY baseline that changed must not be accepted"),
+ };
+ assert!(error.contains("read-only state changed"), "{error}");
+ }
+ #[tokio::test]
+ async fn full_temporal_values_keep_bc_and_ad_distinct_in_the_actual_reader() {
+ let fixture = Fixture::new();
+ for dialect in [Dialect::Oracle, Dialect::OceanBase, Dialect::Dameng] {
+ let query = |sql: String, bc: bool| -> Result<db::QueryResult, String> {
+ if sql.starts_with("SELECT TO_CHAR(T.") {
+ // The database's unsigned YYYY format loses the era. SYYYY
+ // returns the signed year, including for TIMESTAMP(9).
+ let year = if bc && sql.contains("SYYYY") { "-0001" } else { " 0001" };
+ return Ok(answer(
+ &["C0", "C1"],
+ vec![
+ vec![
+ json!(format!("{year}-01-02T03:04:05")),
+ json!(format!("{year}-01-02T03:04:05.123456789")),
+ ];
+ 3
+ ],
+ ));
+ }
+ let mut response = if dialect == Dialect::OceanBase {
+ oceanbase_query(&fixture, sql.clone())?
+ } else {
+ fixture.query(sql.clone())?
+ };
+ if sql.contains("FROM ALL_TAB_COLS") {
+ let kind = response.columns.iter().position(|name| name == "DATA_TYPE").unwrap();
+ response.rows[0][kind] = json!("DATE");
+ response.rows[1][kind] = json!("TIMESTAMP(9)");
+ let scale = response.columns.iter().position(|name| name == "DATA_SCALE").unwrap();
+ response.rows[1][scale] = json!(9);
+ }
+ Ok(response)
+ };
+ let key = OracleTypeDataRelationKey { owner: "APP".into(), name: "OLD".into() };
+ let mut run = |sql| std::future::ready(query(sql, false));
+ let relation = describe(dialect, &key, &mut run).await.unwrap();
+ let ad = read_data(dialect, relation.clone(), &mut run).await.unwrap();
+ let bc = read_data(dialect, relation, &mut |sql| std::future::ready(query(sql, true))).await.unwrap();
+ assert_ne!(ad.baseline.fingerprint, bc.baseline.fingerprint, "{dialect:?}");
+ }
+ }
+ #[tokio::test]
+ async fn declared_width_budget_is_checked_before_any_business_rows_are_fetched() {
+ let mut fixture = Fixture::new();
+ fixture.tables.get_mut("OLD").unwrap().rows = vec![vec![Value::Null, Value::Null]; 100];
+ let fetched = std::cell::Cell::new(false);
+ let mut run = |sql: String| {
+ let result = if sql.starts_with("SELECT TO_CHAR(T.") {
+ fetched.set(true);
+ Err("Unexpected data fetch".into())
+ } else {
+ fixture.query(sql.clone()).map(|mut response| {
+ if sql.contains("FROM ALL_TAB_COLS") {
+ for name in ["DATA_LENGTH", "CHAR_LENGTH"] {
+ let i = response.columns.iter().position(|column| column == name).unwrap();
+ response.rows[1][i] = json!(32767);
+ }
+ }
+ response
+ })
+ };
+ std::future::ready(result)
+ };
+ let key = OracleTypeDataRelationKey { owner: "APP".into(), name: "OLD".into() };
+ let relation = describe(Dialect::Oracle, &key, &mut run).await.unwrap();
+ let error = match read_data(Dialect::Oracle, relation, &mut run).await {
+ Ok(_) => panic!("Oversized metadata must not be fetched"),
+ Err(error) => error,
+ };
+ assert!(error.contains("8 MiB"));
+ assert!(!fetched.get());
+ }
+ #[tokio::test]
+ async fn full_object_projection_keeps_atomic_null_distinct_from_an_all_null_object() {
+ let fixture = Fixture::new();
+ let query = |sql: String, atomic_null: bool| -> Result<db::QueryResult, String> {
+ if sql.contains("FROM ALL_TYPES") {
+ return Ok(answer(
+ &["TYPECODE", "ATTRIBUTES", "FINAL", "INCOMPLETE", "SUPERTYPE_NAME"],
+ vec![vec![json!("OBJECT"), json!(1), json!("YES"), json!("NO"), Value::Null]],
+ ));
+ }
+ if sql.contains("FROM ALL_TYPE_ATTRS") {
+ return Ok(answer(
+ &[
+ "ATTR_NAME",
+ "ATTR_NO",
+ "ATTR_TYPE_MOD",
+ "DATA_TYPE_OWNER",
+ "DATA_TYPE",
+ "DATA_LENGTH",
+ "DATA_PRECISION",
+ "DATA_SCALE",
+ "CHAR_USED",
+ "CHAR_LENGTH",
+ ],
+ vec![vec![
+ json!("ID"),
+ json!(1),
+ Value::Null,
+ Value::Null,
+ json!("NUMBER"),
+ json!(22),
+ json!(18),
+ json!(0),
+ Value::Null,
+ json!(0),
+ ]],
+ ));
+ }
+ if sql.starts_with("SELECT TO_CHAR(T.") {
+ return Ok(answer(
+ &["C0", "C1", "C2"],
+ vec![vec![json!("1"), json!(u8::from(atomic_null)), Value::Null]; 3],
+ ));
+ }
+ let mut response = fixture.query(sql.clone())?;
+ if sql.contains("FROM ALL_TAB_COLS") {
+ let mut assign = |column: &str, value: Value| {
+ let index = response.columns.iter().position(|name| name == column).unwrap();
+ response.rows[1][index] = value;
+ };
+ assign("COLUMN_NAME", json!("VALUE"));
+ assign("DATA_TYPE", json!("ROOT"));
+ assign("DATA_TYPE_OWNER", json!("APP"));
+ }
+ Ok(response)
+ };
+ let key = OracleTypeDataRelationKey { owner: "APP".into(), name: "SRC".into() };
+ let mut run = |sql| std::future::ready(query(sql, false));
+ let relation = describe(Dialect::Oracle, &key, &mut run).await.unwrap();
+ assert_eq!(
+ relation.projection.iter().map(|p| (p.path.clone(), p.object_null)).collect::<Vec<_>>(),
+ vec![(vec!["ID".into()], false), (vec!["VALUE".into()], true), (vec!["VALUE".into(), "ID".into()], false)]
+ );
+ let all_null = read_data(Dialect::Oracle, relation.clone(), &mut run).await.unwrap();
+ let atomic_null =
+ read_data(Dialect::Oracle, relation, &mut |sql| std::future::ready(query(sql, true))).await.unwrap();
+ assert_ne!(all_null.baseline.fingerprint, atomic_null.baseline.fingerprint);
+ assert_eq!(all_null.baseline.row_count, 3);
+ }
+ #[tokio::test]
+ async fn actual_registration_and_cross_session_verification_preserve_full_duplicate_null_and_large_values() {
+ let fixture = Fixture::new();
+ let original = fixture.call("register", None, None).await.unwrap().manifest.unwrap();
+ assert_eq!(original.original.row_count, 3);
+ assert!(original.verified_target.is_none());
+ let persisted = serde_json::to_string(&original).unwrap();
+ assert!(!persisted.contains("90071992547409931234567890.1200"));
+ let mut other_session = fixture.clone();
+ other_session.tables.get_mut("RESULT").unwrap().rows =
+ other_session.tables["EXPECTED"].rows.iter().rev().cloned().collect();
+ other_session.tables.remove("SRC"); // external preparation removed the original TYPE reference
+ let result = other_session
+ .call("verify", Some(serde_json::from_str(&persisted).unwrap()), None)
+ .await
+ .unwrap()
+ .manifest
+ .unwrap();
+ assert_eq!(result.verified_target.unwrap().row_count, 3);
+ assert_eq!(result.old, original.old);
+ }
+ #[tokio::test]
+ async fn baseline_identity_readonly_values_and_multiplicities_cannot_be_replaced_on_resume() {
+ let fixture = Fixture::new();
+ let original = fixture.call("register", None, None).await.unwrap().manifest.unwrap();
+ for change in ["id", "readonly", "values", "duplicates"] {
+ let mut changed = fixture.clone();
+ match change {
+ "id" => changed.tables.get_mut("OLD").unwrap().id = "new-id".into(),
+ "readonly" => changed.tables.get_mut("OLD").unwrap().readonly = None,
+ "values" => changed.tables.get_mut("OLD").unwrap().rows[0][1] = json!("changed"),
+ _ => {
+ changed.tables.get_mut("OLD").unwrap().rows.pop();
+ }
+ }
+ assert!(changed.call("verify", Some(original.clone()), None).await.is_err(), "{change}");
+ }
+ }
+ #[tokio::test]
+ async fn missing_or_lossy_complete_reads_never_create_an_integrity_fingerprint() {
+ for fault in ["truncated", "has-more", "lossy-number", "large-cell", "silent-limit"] {
+ let mut fixture = Fixture::new();
+ fixture.fault = Some(fault);
+ assert!(fixture.call("register", None, None).await.is_err(), "{fault}");
+ }
+ let mut fixture = Fixture::new();
+ fixture.tables.get_mut("OLD").unwrap().rows[1][0] = json!("90071992547409931234567890.1201");
+ assert!(fixture.call("register", None, None).await.is_err());
+ }
+ #[tokio::test]
+ async fn bounded_insert_requires_the_same_empty_scalar_target_without_implicit_execution() {
+ let fixture = Fixture::new();
+ let manifest = fixture.call("register", None, None).await.unwrap().manifest.unwrap();
+ let sql = "INSERT INTO APP.RESULT(ID,LABEL) SELECT ID,LABEL FROM APP.EXPECTED";
+ let preview = fixture.call("validate_insert", Some(manifest.clone()), Some(sql)).await.unwrap();
+ assert!(preview.insert_sql.unwrap().starts_with("INSERT INTO \"APP\".\"RESULT\""));
+ let mut replaced = fixture.clone();
+ replaced.tables.get_mut("RESULT").unwrap().id = "replacement".into();
+ assert!(replaced.call("validate_insert", preview.manifest, Some(sql)).await.is_err());
+ for fault in ["trigger", "function-index"] {
+ let mut blocked = fixture.clone();
+ blocked.fault = Some(fault);
+ assert!(blocked.call("validate_insert", Some(manifest.clone()), Some(sql)).await.is_err(), "{fault}");
+ }
+ let mut nonempty = fixture.clone();
+ nonempty.tables.get_mut("RESULT").unwrap().rows.push(vec![json!("1"), json!("x")]);
+ assert!(nonempty.call("validate_insert", Some(manifest), Some(sql)).await.is_err());
+ }
+ #[test]
+ fn exact_decimal_canonicalization_never_uses_a_float() {
+ assert_eq!(
+ decimal("900719925474099312345678901234567890.12000").unwrap(),
+ "90071992547409931234567890123456789012e-2"
+ );
+ assert_eq!(decimal("1.2000E+2").unwrap(), decimal("120").unwrap());
+ assert_eq!(decimal("-0.000").unwrap(), "0");
+ for value in ["NaN", "1,2", "1.2.3", "", "1E9999"] {
+ assert!(decimal(value).is_err());
+ }
+ }
+ #[test]
+ fn binary_multisets_preserve_duplicates_nulls_and_exact_text() {
+ let ty = vec![ScalarType::parse("VARCHAR2(80 BYTE)").unwrap()];
+ let encode = |rows: Vec<Option<&str>>| {
+ digest(rows.into_iter().map(|s| encode_row(&[s.map(String::from)], &ty)).collect(), &ty, false)
+ };
+ assert_eq!(encode(vec![Some("A"), None, Some("A")]), encode(vec![None, Some("A"), Some("A")]));
+ assert_ne!(encode(vec![Some("A"), None, Some("A")]), encode(vec![None, Some("A")]));
+ assert_ne!(encode(vec![Some("A")]), encode(vec![Some("a")]));
+ assert_ne!(encode(vec![Some("A ")]), encode(vec![Some("A")]));
+ assert_ne!(encode(vec![None]), encode(vec![Some("")]));
+ }
+}
diff --git a/crates/dbx-core/src/schema/oracle_type_details.rs b/crates/dbx-core/src/schema/oracle_type_details.rs
new file mode 100644
index 0000000000..5b168d8999
--- /dev/null
+++ b/crates/dbx-core/src/schema/oracle_type_details.rs
@@ -0,0 +1,977 @@
+//! Oracle-family type dictionaries, shared by Agent and external JDBC query
+//! transports. Keep dictionary completeness separate from source/DDL semantics.
+
+use super::{is_oracle_external_driver_config, sql_string};
+use crate::db;
+use crate::models::connection::{ConnectionConfig, DatabaseType};
+use db::{
+ CustomTypeDetails, CustomTypeKind, CustomTypeProperties, OracleTypeAttribute, OracleTypeCollection,
+ OracleTypeMetadata, OracleTypeMethod, OracleTypeMethodParameter, TypeMetadataRead, TypeMetadataState,
+};
+use serde_json::Value;
+use std::future::Future;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum Dialect {
+ Oracle,
+ OceanBase,
+ Dameng,
+}
+
+pub(super) fn dialect(config: &ConnectionConfig) -> Option<Dialect> {
+ match config.db_type {
+ DatabaseType::Oracle => Some(Dialect::Oracle),
+ DatabaseType::OceanbaseOracle => Some(Dialect::OceanBase),
+ DatabaseType::Dameng => Some(Dialect::Dameng),
+ DatabaseType::Jdbc
+ if config
+ .connection_string
+ .as_deref()
+ .is_some_and(|url| url.trim().to_ascii_lowercase().starts_with("jdbc:oceanbase:oracle://")) =>
+ {
+ Some(Dialect::OceanBase)
+ }
+ DatabaseType::Jdbc if is_oracle_external_driver_config(config) => Some(Dialect::Oracle),
+ DatabaseType::Jdbc
+ if config
+ .connection_string
+ .as_deref()
+ .is_some_and(|url| url.trim().to_ascii_lowercase().starts_with("jdbc:dm:")) =>
+ {
+ Some(Dialect::Dameng)
+ }
+ _ => None,
+ }
+}
+
+fn available() -> TypeMetadataRead {
+ TypeMetadataRead { state: TypeMetadataState::Available, reason: None }
+}
+
+fn incomplete(read: &mut TypeMetadataRead, reason: impl Into<String>) {
+ if read.state == TypeMetadataState::Unavailable || read.state == TypeMetadataState::Unsupported {
+ return;
+ }
+ read.state = TypeMetadataState::Incomplete;
+ let reason = reason.into();
+ read.reason = Some(match read.reason.take() {
+ Some(previous) => format!("{previous}; {reason}"),
+ None => reason,
+ });
+}
+
+struct Dictionary {
+ result: Option<db::QueryResult>,
+ read: TypeMetadataRead,
+}
+
+impl Dictionary {
+ fn new(result: Result<db::QueryResult, String>, required: &[&str]) -> Self {
+ match result {
+ Err(error) => Self {
+ result: None,
+ read: TypeMetadataRead { state: TypeMetadataState::Unavailable, reason: Some(error) },
+ },
+ Ok(result) => {
+ let mut read = available();
+ if result.truncated || result.has_more {
+ incomplete(&mut read, "Dictionary rows were truncated");
+ }
+ let missing: Vec<_> = required
+ .iter()
+ .filter(|name| !result.columns.iter().any(|column| column.eq_ignore_ascii_case(name)))
+ .copied()
+ .collect();
+ if !missing.is_empty() {
+ incomplete(&mut read, format!("Missing dictionary columns: {}", missing.join(", ")));
+ }
+ Self { result: Some(result), read }
+ }
+ }
+ }
+
+ fn value<'a>(&self, row: &'a [Value], column: &str) -> Option<&'a Value> {
+ self.result
+ .as_ref()?
+ .columns
+ .iter()
+ .position(|name| name.eq_ignore_ascii_case(column))
+ .and_then(|index| row.get(index))
+ .filter(|value| !value.is_null())
+ }
+
+ fn has_column(&self, column: &str) -> bool {
+ self.result.as_ref().is_some_and(|result| result.columns.iter().any(|name| name.eq_ignore_ascii_case(column)))
+ }
+
+ fn text(&self, row: &[Value], column: &str) -> Option<String> {
+ self.value(row, column).and_then(|value| match value {
+ Value::String(text) if !text.is_empty() => Some(text.clone()),
+ Value::Number(number) => Some(number.to_string()),
+ _ => None,
+ })
+ }
+
+ fn integer(&self, row: &[Value], column: &str) -> Option<i64> {
+ self.value(row, column).and_then(|value| value.as_i64().or_else(|| value.as_str()?.parse().ok()))
+ }
+
+ fn small_integer(&self, row: &[Value], column: &str) -> Option<i32> {
+ self.integer(row, column).and_then(|value| value.try_into().ok())
+ }
+
+ fn count(&self, row: &[Value], column: &str) -> Option<u32> {
+ self.integer(row, column).and_then(|value| value.try_into().ok())
+ }
+
+ fn yes_no(&self, row: &[Value], column: &str) -> Option<bool> {
+ match self.text(row, column)?.to_ascii_uppercase().as_str() {
+ "YES" => Some(true),
+ "NO" => Some(false),
+ _ => None,
+ }
+ }
+
+ fn target_rows(&self, owner: &str, name: &str, name_column: &str) -> Vec<&[Value]> {
+ self.result
+ .iter()
+ .flat_map(|result| result.rows.iter())
+ .filter(|row| {
+ self.text(row, "OWNER").as_deref() == Some(owner)
+ && self.text(row, name_column).as_deref() == Some(name)
+ })
+ .map(Vec::as_slice)
+ .collect()
+ }
+}
+
+fn check_count(read: &mut TypeMetadataRead, expected: Option<u32>, actual: usize) {
+ match expected {
+ Some(expected) if expected as usize != actual => {
+ incomplete(read, format!("Dictionary count is {expected}, but {actual} rows were read"));
+ }
+ None => incomplete(read, "Dictionary count is unknown"),
+ _ => {}
+ }
+}
+
+fn precision(dictionary: &Dictionary, row: &[Value], dialect: Dialect) -> Option<i32> {
+ // OceanBase 4.2.5.7 exposes NUMBER_PRECISION, while Oracle uses PRECISION.
+ let columns = if dialect == Dialect::OceanBase {
+ ["NUMBER_PRECISION", "PRECISION"]
+ } else {
+ ["PRECISION", "NUMBER_PRECISION"]
+ };
+ columns.iter().find_map(|column| dictionary.small_integer(row, column))
+}
+
+struct TypeDimensions {
+ length: Option<i64>,
+ precision: Option<i32>,
+ scale: Option<i32>,
+}
+
+fn type_dimensions(dictionary: &Dictionary, row: &[Value], type_column: &str, dialect: Dialect) -> TypeDimensions {
+ let mut dimensions = TypeDimensions {
+ length: dictionary.integer(row, "LENGTH"),
+ precision: precision(dictionary, row, dialect),
+ scale: dictionary.small_integer(row, "SCALE"),
+ };
+ if dialect == Dialect::OceanBase {
+ // OB 4.2.5 exposes internal accuracy sentinels (-1 / -85), and even
+ // VARCHAR2 rows have NUMBER_PRECISION=2, SCALE=-1. These are not SQL
+ // type dimensions. Preserve valid negative NUMBER scales, e.g. -2.
+ let type_name = dictionary.text(row, type_column).unwrap_or_default().to_ascii_uppercase();
+ let decimal = matches!(type_name.as_str(), "NUMBER" | "DECIMAL" | "NUMERIC" | "DEC");
+ dimensions.length = dimensions.length.filter(|value| *value >= 0);
+ dimensions.precision = dimensions.precision.filter(|value| (decimal || type_name == "FLOAT") && *value > 0);
+ dimensions.scale = dimensions.scale.filter(|value| decimal && *value != -85);
+ }
+ dimensions
+}
+
+fn check_precision_column(dictionary: &Dictionary, read: &mut TypeMetadataRead) {
+ if !dictionary.has_column("PRECISION") && !dictionary.has_column("NUMBER_PRECISION") {
+ incomplete(read, "Missing dictionary precision column");
+ }
+}
+
+fn method_rows<'a>(dictionary: &'a Dictionary, owner: &str, name: &str, method: &OracleTypeMethod) -> Vec<&'a [Value]> {
+ // METHOD_NO is required to distinguish overloads; never attach a same-name
+ // parameter from a different overload when that identity is unavailable.
+ let Some(number) = method.number else { return Vec::new() };
+ dictionary
+ .target_rows(owner, name, "TYPE_NAME")
+ .into_iter()
+ .filter(|row| {
+ dictionary.text(row, "METHOD_NAME").as_deref() == Some(&method.name)
+ && dictionary.small_integer(row, "METHOD_NO") == Some(number)
+ })
+ .collect()
+}
+
+pub(super) async fn read<F, Fut>(
+ dialect: Dialect,
+ schema: &str,
+ name: &str,
+ mut run: F,
+) -> Result<CustomTypeDetails, String>
+where
+ F: FnMut(String) -> Fut,
+ Fut: Future<Output = Result<db::QueryResult, String>>,
+{
+ if schema.is_empty() || name.is_empty() {
+ return Err("schema and type name are required".to_string());
+ }
+ let owner = sql_string(schema);
+ let type_name = sql_string(name);
+ let predicate = format!("OWNER = {owner} AND TYPE_NAME = {type_name}");
+ let objects = Dictionary::new(
+ run(format!("SELECT OWNER, OBJECT_NAME, OBJECT_TYPE, STATUS FROM ALL_OBJECTS WHERE OWNER = {owner} AND OBJECT_NAME = {type_name} AND OBJECT_TYPE IN ('TYPE', 'TYPE BODY')")).await,
+ &["OWNER", "OBJECT_NAME", "OBJECT_TYPE", "STATUS"],
+ );
+ // SELECT * tolerates vendor/version column differences without requiring a
+ // wider catalog privilege or silently substituting invented field values.
+ let types = Dictionary::new(
+ run(format!("SELECT * FROM ALL_TYPES WHERE {predicate}")).await,
+ &[
+ "OWNER",
+ "TYPE_NAME",
+ "TYPECODE",
+ "ATTRIBUTES",
+ "METHODS",
+ "FINAL",
+ "INSTANTIABLE",
+ "SUPERTYPE_OWNER",
+ "SUPERTYPE_NAME",
+ ],
+ );
+ let object_rows = objects.target_rows(schema, name, "OBJECT_NAME");
+ let type_row = object_rows.iter().copied().find(|row| objects.text(row, "OBJECT_TYPE").as_deref() == Some("TYPE"));
+ let body_row =
+ object_rows.iter().copied().find(|row| objects.text(row, "OBJECT_TYPE").as_deref() == Some("TYPE BODY"));
+ let general_rows = types.target_rows(schema, name, "TYPE_NAME");
+ let general = general_rows.first().copied();
+ if type_row.is_none() && general.is_none() {
+ let reasons: Vec<_> = [&objects.read.reason, &types.read.reason].into_iter().flatten().cloned().collect();
+ return Err(format!(
+ "Type {schema}.{name} was not found or is not visible{}",
+ if reasons.is_empty() { String::new() } else { format!(": {}", reasons.join("; ")) }
+ ));
+ }
+
+ let type_code = general.and_then(|row| types.text(row, "TYPECODE"));
+ let kind = match type_code.as_deref().map(str::to_ascii_uppercase).as_deref() {
+ Some("OBJECT") => CustomTypeKind::Object,
+ Some("COLLECTION") => CustomTypeKind::Collection,
+ _ => CustomTypeKind::Other,
+ };
+ let attribute_count = general.and_then(|row| types.count(row, "ATTRIBUTES"));
+ let method_count = general.and_then(|row| types.count(row, "METHODS"));
+ let mut properties_read = types.read.clone();
+ if general.is_none() || type_code.is_none() {
+ incomplete(&mut properties_read, "Type properties are not visible");
+ }
+ if objects.read.state != TypeMetadataState::Available
+ || type_row.and_then(|row| objects.text(row, "STATUS")).is_none()
+ {
+ incomplete(
+ &mut properties_read,
+ objects.read.reason.clone().unwrap_or_else(|| "Type status is unknown".to_string()),
+ );
+ }
+ let mut body_read = objects.read.clone();
+ if body_row.is_some_and(|row| objects.text(row, "STATUS").is_none()) {
+ incomplete(&mut body_read, "Type body status is unknown");
+ }
+
+ let attrs = Dictionary::new(
+ run(format!("SELECT * FROM ALL_TYPE_ATTRS WHERE {predicate}")).await,
+ &["OWNER", "TYPE_NAME", "ATTR_NAME", "ATTR_NO", "ATTR_TYPE_OWNER", "ATTR_TYPE_NAME", "LENGTH", "SCALE"],
+ );
+ let mut attributes_read = attrs.read.clone();
+ check_precision_column(&attrs, &mut attributes_read);
+ let mut attributes = Vec::new();
+ for row in attrs.target_rows(schema, name, "TYPE_NAME") {
+ let Some(attr_name) = attrs.text(row, "ATTR_NAME") else {
+ incomplete(&mut attributes_read, "An attribute name is missing");
+ continue;
+ };
+ let dimensions = type_dimensions(&attrs, row, "ATTR_TYPE_NAME", dialect);
+ let attribute = OracleTypeAttribute {
+ name: attr_name,
+ ordinal: attrs.small_integer(row, "ATTR_NO"),
+ type_owner: attrs.text(row, "ATTR_TYPE_OWNER"),
+ type_name: attrs.text(row, "ATTR_TYPE_NAME"),
+ type_modifier: attrs.text(row, "ATTR_TYPE_MOD"),
+ length: dimensions.length,
+ precision: dimensions.precision,
+ scale: dimensions.scale,
+ };
+ if attribute.ordinal.is_none() || attribute.type_name.is_none() {
+ incomplete(&mut attributes_read, "Attribute order or type is unknown");
+ }
+ attributes.push(attribute);
+ }
+ attributes.sort_by_key(|attribute| attribute.ordinal.unwrap_or(i32::MAX));
+ check_count(&mut attributes_read, attribute_count, attributes.len());
+
+ let method_dictionary = Dictionary::new(
+ run(format!("SELECT * FROM ALL_TYPE_METHODS WHERE {predicate}")).await,
+ &["OWNER", "TYPE_NAME", "METHOD_NAME", "METHOD_NO", "METHOD_TYPE", "PARAMETERS", "RESULTS"],
+ );
+ let mut methods_read = method_dictionary.read.clone();
+ let mut methods = Vec::new();
+ for row in method_dictionary.target_rows(schema, name, "TYPE_NAME") {
+ let Some(method_name) = method_dictionary.text(row, "METHOD_NAME") else {
+ incomplete(&mut methods_read, "A method name is missing");
+ continue;
+ };
+ let number = method_dictionary.small_integer(row, "METHOD_NO");
+ if number.is_none() || method_dictionary.text(row, "METHOD_TYPE").is_none() {
+ incomplete(&mut methods_read, "A method overload number or kind is unknown");
+ }
+ methods.push(OracleTypeMethod {
+ name: method_name,
+ number,
+ kind: method_dictionary.text(row, "METHOD_TYPE"),
+ parameter_count: method_dictionary.count(row, "PARAMETERS"),
+ result_count: method_dictionary.count(row, "RESULTS"),
+ parameters: Vec::new(),
+ results: Vec::new(),
+ parameters_read: available(),
+ results_read: available(),
+ });
+ }
+ methods.sort_by_key(|method| method.number.unwrap_or(i32::MAX));
+ check_count(&mut methods_read, method_count, methods.len());
+ if !methods.is_empty() {
+ let params = Dictionary::new(
+ run(format!("SELECT * FROM ALL_METHOD_PARAMS WHERE {predicate}")).await,
+ &[
+ "OWNER",
+ "TYPE_NAME",
+ "METHOD_NAME",
+ "METHOD_NO",
+ "PARAM_NAME",
+ "PARAM_NO",
+ "PARAM_MODE",
+ "PARAM_TYPE_OWNER",
+ "PARAM_TYPE_NAME",
+ ],
+ );
+ let results = Dictionary::new(
+ run(format!("SELECT * FROM ALL_METHOD_RESULTS WHERE {predicate}")).await,
+ &["OWNER", "TYPE_NAME", "METHOD_NAME", "METHOD_NO", "RESULT_TYPE_OWNER", "RESULT_TYPE_NAME"],
+ );
+ for method in &mut methods {
+ method.parameters_read = params.read.clone();
+ method.results_read = results.read.clone();
+ for row in method_rows(&params, schema, name, method) {
+ method.parameters.push(OracleTypeMethodParameter {
+ name: params.text(row, "PARAM_NAME"),
+ ordinal: params.small_integer(row, "PARAM_NO"),
+ mode: params.text(row, "PARAM_MODE"),
+ type_owner: params.text(row, "PARAM_TYPE_OWNER"),
+ type_name: params.text(row, "PARAM_TYPE_NAME"),
+ type_modifier: params.text(row, "PARAM_TYPE_MOD"),
+ });
+ }
+ method.parameters.sort_by_key(|parameter| parameter.ordinal.unwrap_or(i32::MAX));
+ for row in method_rows(&results, schema, name, method) {
+ method.results.push(OracleTypeMethodParameter {
+ name: None,
+ ordinal: None,
+ mode: None,
+ type_owner: results.text(row, "RESULT_TYPE_OWNER"),
+ type_name: results.text(row, "RESULT_TYPE_NAME"),
+ type_modifier: results.text(row, "RESULT_TYPE_MOD"),
+ });
+ }
+ check_count(&mut method.parameters_read, method.parameter_count, method.parameters.len());
+ check_count(&mut method.results_read, method.result_count, method.results.len());
+ if method.parameters.iter().any(|parameter| parameter.ordinal.is_none() || parameter.type_name.is_none()) {
+ incomplete(&mut method.parameters_read, "Parameter order or type is unknown");
+ }
+ if method.results.iter().any(|result| result.type_name.is_none()) {
+ incomplete(&mut method.results_read, "Result type is unknown");
+ }
+ if method.parameters_read.state != TypeMetadataState::Available
+ || method.results_read.state != TypeMetadataState::Available
+ {
+ incomplete(
+ &mut methods_read,
+ format!("Method {} has incomplete parameter or result metadata", method.name),
+ );
+ }
+ }
+ }
+
+ let collections = Dictionary::new(
+ run(format!("SELECT * FROM ALL_COLL_TYPES WHERE {predicate}")).await,
+ &["OWNER", "TYPE_NAME", "COLL_TYPE", "ELEM_TYPE_OWNER", "ELEM_TYPE_NAME", "LENGTH", "SCALE"],
+ );
+ let mut collection_read = collections.read.clone();
+ check_precision_column(&collections, &mut collection_read);
+ let collection_rows = collections.target_rows(schema, name, "TYPE_NAME");
+ let collection = collection_rows.first().map(|row| {
+ let dimensions = type_dimensions(&collections, row, "ELEM_TYPE_NAME", dialect);
+ let upper_bound = collections.integer(row, "UPPER_BOUND").filter(|value| *value > 0);
+ let raw_kind = collections.text(row, "COLL_TYPE");
+ // OB 4.2.5 reports TABLE for both SQL collection kinds. A positive
+ // UPPER_BOUND is documented only for varrays; -1 means unbounded.
+ let collection_kind =
+ if dialect == Dialect::OceanBase && raw_kind.as_deref() == Some("TABLE") && upper_bound.is_some() {
+ Some("VARRAY".to_string())
+ } else {
+ raw_kind
+ };
+ if dialect == Dialect::OceanBase && !collections.has_column("UPPER_BOUND") {
+ incomplete(&mut collection_read, "Collection upper bound column is missing");
+ }
+ OracleTypeCollection {
+ kind: collection_kind,
+ upper_bound,
+ element_owner: collections.text(row, "ELEM_TYPE_OWNER"),
+ element_name: collections.text(row, "ELEM_TYPE_NAME"),
+ element_modifier: collections.text(row, "ELEM_TYPE_MOD"),
+ length: dimensions.length,
+ precision: dimensions.precision,
+ scale: dimensions.scale,
+ }
+ });
+ if kind == CustomTypeKind::Collection && collection.is_none() {
+ incomplete(&mut collection_read, "Collection details are not visible");
+ }
+ if let Some(collection) = &collection {
+ if collection.kind.is_none() || collection.element_name.is_none() {
+ incomplete(&mut collection_read, "Collection kind or element type is unknown");
+ }
+ if collection.kind.as_deref().is_some_and(|kind| kind.to_ascii_uppercase().contains("ARRAY"))
+ && collection.upper_bound.is_none()
+ {
+ incomplete(&mut collection_read, "Collection upper bound is unknown");
+ }
+ }
+ Ok(CustomTypeDetails {
+ name: name.to_string(),
+ schema: schema.to_string(),
+ kind,
+ comment: None,
+ members: Vec::new(),
+ properties: CustomTypeProperties::default(),
+ ddl: None,
+ oracle_metadata: Some(OracleTypeMetadata {
+ status: type_row.and_then(|row| objects.text(row, "STATUS")),
+ type_code,
+ is_final: general.and_then(|row| types.yes_no(row, "FINAL")),
+ instantiable: general.and_then(|row| types.yes_no(row, "INSTANTIABLE")),
+ supertype_owner: general.and_then(|row| types.text(row, "SUPERTYPE_OWNER")),
+ supertype_name: general.and_then(|row| types.text(row, "SUPERTYPE_NAME")),
+ attribute_count,
+ method_count,
+ body_visible: if body_row.is_some() {
+ Some(true)
+ } else if objects.read.state == TypeMetadataState::Available {
+ Some(false)
+ } else {
+ None
+ },
+ body_status: body_row.and_then(|row| objects.text(row, "STATUS")),
+ properties_read,
+ body_read,
+ attributes_read,
+ methods_read,
+ collection_read,
+ attributes,
+ methods,
+ collection,
+ }),
+ })
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use serde_json::json;
+ use std::collections::HashMap;
+
+ #[test]
+ fn explicit_oceanbase_oracle_jdbc_mode_selects_only_the_oceanbase_type_dialect() {
+ let mut config: ConnectionConfig = serde_json::from_value(json!({
+ "id": "ob-jdbc", "name": "OB JDBC", "db_type": "jdbc", "host": "localhost", "port": 2881,
+ "username": "APP", "password": "", "database": "APP", "jdbc_driver_class": "com.oceanbase.jdbc.Driver"
+ }))
+ .unwrap();
+ for (url, expected) in [
+ (" JDBC:OceanBase:Oracle://localhost:2881/APP ", Some(Dialect::OceanBase)),
+ ("jdbc:oceanbase://localhost:2881/APP", None),
+ ("jdbc:oceanbase:mysql://localhost:2881/APP", None),
+ ("jdbc:mysql://localhost:2881/APP", None),
+ ] {
+ config.connection_string = Some(url.into());
+ assert_eq!(dialect(&config), expected, "{url}");
+ assert!(!is_oracle_external_driver_config(&config), "OB must not change the generic Oracle predicate");
+ }
+ }
+
+ fn query_result(columns: &[&str], rows: Vec<Vec<Value>>) -> db::QueryResult {
+ serde_json::from_value(json!({
+ "columns": columns, "rows": rows, "affected_rows": 0, "execution_time_ms": 0,
+ }))
+ .unwrap()
+ }
+
+ struct Fixture {
+ schema: String,
+ name: String,
+ results: HashMap<&'static str, Result<db::QueryResult, String>>,
+ }
+
+ impl Fixture {
+ fn new(code: &str, attributes: Value, methods: Value) -> Self {
+ let schema = "Exact O'wner".to_string();
+ let name = "Mixed Type".to_string();
+ let mut results = HashMap::new();
+ results.insert(
+ "ALL_OBJECTS",
+ Ok(query_result(
+ &["OWNER", "OBJECT_NAME", "OBJECT_TYPE", "STATUS"],
+ vec![
+ vec![json!(schema), json!(name), json!("TYPE"), json!("VALID")],
+ vec![json!(schema), json!(name), json!("TYPE BODY"), json!("INVALID")],
+ ],
+ )),
+ );
+ results.insert(
+ "ALL_TYPES",
+ Ok(query_result(
+ &[
+ "OWNER",
+ "TYPE_NAME",
+ "TYPECODE",
+ "ATTRIBUTES",
+ "METHODS",
+ "FINAL",
+ "INSTANTIABLE",
+ "SUPERTYPE_OWNER",
+ "SUPERTYPE_NAME",
+ ],
+ vec![vec![
+ json!(schema),
+ json!(name),
+ json!(code),
+ attributes,
+ methods,
+ json!("NO"),
+ json!("YES"),
+ Value::Null,
+ Value::Null,
+ ]],
+ )),
+ );
+ results.insert(
+ "ALL_TYPE_ATTRS",
+ Ok(query_result(
+ &[
+ "OWNER",
+ "TYPE_NAME",
+ "ATTR_NAME",
+ "ATTR_NO",
+ "ATTR_TYPE_OWNER",
+ "ATTR_TYPE_NAME",
+ "LENGTH",
+ "PRECISION",
+ "SCALE",
+ ],
+ vec![],
+ )),
+ );
+ results.insert(
+ "ALL_TYPE_METHODS",
+ Ok(query_result(
+ &["OWNER", "TYPE_NAME", "METHOD_NAME", "METHOD_NO", "METHOD_TYPE", "PARAMETERS", "RESULTS"],
+ vec![],
+ )),
+ );
+ results.insert(
+ "ALL_COLL_TYPES",
+ Ok(query_result(
+ &[
+ "OWNER",
+ "TYPE_NAME",
+ "COLL_TYPE",
+ "ELEM_TYPE_OWNER",
+ "ELEM_TYPE_NAME",
+ "LENGTH",
+ "PRECISION",
+ "SCALE",
+ ],
+ vec![],
+ )),
+ );
+ Self { schema, name, results }
+ }
+
+ async fn read(mut self, dialect: Dialect) -> Result<CustomTypeDetails, String> {
+ let mut calls = Vec::new();
+ let details = read(dialect, &self.schema, &self.name, |sql| {
+ assert!(sql.contains("OWNER = 'Exact O''wner'"), "{sql}");
+ assert!(sql.contains("= 'Mixed Type'"), "{sql}");
+ assert!(!sql.contains("CURRENT_SCHEMA"));
+ let view = sql.split(" FROM ").nth(1).unwrap().split_whitespace().next().unwrap();
+ calls.push(view.to_string());
+ std::future::ready(self.results.remove(view).unwrap_or_else(|| panic!("Unexpected query: {sql}")))
+ })
+ .await;
+ assert_eq!(
+ calls.len(),
+ calls.iter().collect::<std::collections::HashSet<_>>().len(),
+ "no repeated fallback to another identity"
+ );
+ details
+ }
+ }
+
+ #[tokio::test]
+ async fn object_attributes_preserve_exact_identity_order_and_oceanbase_precision() {
+ let mut fixture = Fixture::new("OBJECT", json!(2), json!(1));
+ fixture.results.insert(
+ "ALL_TYPE_ATTRS",
+ Ok(query_result(
+ &[
+ "OWNER",
+ "TYPE_NAME",
+ "ATTR_NAME",
+ "ATTR_NO",
+ "ATTR_TYPE_OWNER",
+ "ATTR_TYPE_NAME",
+ "NUMBER_PRECISION",
+ "SCALE",
+ "LENGTH",
+ ],
+ vec![
+ vec![
+ json!(fixture.schema),
+ json!(fixture.name),
+ json!("LABEL"),
+ json!("2"),
+ Value::Null,
+ json!("VARCHAR2"),
+ Value::Null,
+ Value::Null,
+ json!(40),
+ ],
+ vec![
+ json!("Other owner"),
+ json!(fixture.name),
+ json!("DO_NOT_LEAK"),
+ json!(1),
+ Value::Null,
+ json!("NUMBER"),
+ json!(99),
+ json!(0),
+ Value::Null,
+ ],
+ vec![
+ json!(fixture.schema),
+ json!(fixture.name),
+ json!("ID"),
+ json!(1),
+ Value::Null,
+ json!("NUMBER"),
+ json!(12),
+ json!(2),
+ Value::Null,
+ ],
+ ],
+ )),
+ );
+ let details = fixture.read(Dialect::OceanBase).await.unwrap();
+ assert_eq!(details.kind, CustomTypeKind::Object);
+ assert!(details.ddl.is_none(), "source completeness must not redefine PG executable DDL");
+ let serialized = serde_json::to_value(details).unwrap();
+ assert_eq!(serialized["oracleMetadata"]["typeCode"], "OBJECT");
+ assert_eq!(serialized["oracleMetadata"]["attributes"][0]["precision"], 12);
+ assert_eq!(serialized["oracleMetadata"]["methodsRead"]["state"], "incomplete");
+ let restored: CustomTypeDetails = serde_json::from_value(serialized).unwrap();
+ let metadata = restored.oracle_metadata.unwrap();
+ assert_eq!(metadata.body_visible, Some(true));
+ assert_eq!(metadata.body_status.as_deref(), Some("INVALID"));
+ assert_eq!(metadata.attributes[0].name, "ID");
+ assert_eq!(metadata.attributes[0].precision, Some(12));
+ assert_eq!(metadata.attributes[0].scale, Some(2));
+ assert_eq!(metadata.attributes[1].length, Some(40));
+ assert_eq!(metadata.attributes_read.state, TypeMetadataState::Available);
+ assert!(metadata.methods.is_empty());
+ assert_eq!(metadata.methods_read.state, TypeMetadataState::Incomplete);
+ let reason = metadata.methods_read.reason.unwrap();
+ assert!(reason.contains("count is 1") && reason.contains("0 rows"), "{reason}");
+ }
+
+ #[tokio::test]
+ async fn oceanbase_internal_accuracy_values_are_not_type_dimensions() {
+ let mut fixture = Fixture::new("OBJECT", json!(4), json!(0));
+ let rows = [
+ ("UNBOUNDED", "NUMBER", -1, -1, -85),
+ ("ROUNDED", "NUMBER", -1, 12, -2),
+ ("LABEL", "VARCHAR2", 40, 2, -1),
+ ("BINARY_PRECISION", "FLOAT", -1, 126, -1),
+ ];
+ fixture.results.insert(
+ "ALL_TYPE_ATTRS",
+ Ok(query_result(
+ &[
+ "OWNER",
+ "TYPE_NAME",
+ "ATTR_NAME",
+ "ATTR_NO",
+ "ATTR_TYPE_OWNER",
+ "ATTR_TYPE_NAME",
+ "LENGTH",
+ "NUMBER_PRECISION",
+ "SCALE",
+ ],
+ rows.into_iter()
+ .enumerate()
+ .map(|(index, (name, type_name, length, precision, scale))| {
+ vec![
+ json!(fixture.schema),
+ json!(fixture.name),
+ json!(name),
+ json!(index + 1),
+ Value::Null,
+ json!(type_name),
+ json!(length),
+ json!(precision),
+ json!(scale),
+ ]
+ })
+ .collect(),
+ )),
+ );
+ let metadata = fixture.read(Dialect::OceanBase).await.unwrap().oracle_metadata.unwrap();
+ let attributes = metadata.attributes;
+ assert_eq!((attributes[0].length, attributes[0].precision, attributes[0].scale), (None, None, None));
+ assert_eq!((attributes[1].precision, attributes[1].scale), (Some(12), Some(-2)));
+ assert_eq!((attributes[2].length, attributes[2].precision, attributes[2].scale), (Some(40), None, None));
+ assert_eq!((attributes[3].precision, attributes[3].scale), (Some(126), None));
+ assert_eq!(metadata.attributes_read.state, TypeMetadataState::Available);
+ }
+
+ #[tokio::test]
+ async fn oceanbase_collection_bound_distinguishes_varray_from_unbounded_table() {
+ for (bound, element, length, precision, scale, expected_kind, expected_bound) in
+ [(-1, "VARCHAR2", 30, 2, -1, "TABLE", None), (10, "NUMBER", -1, -1, -85, "VARRAY", Some(10))]
+ {
+ let mut fixture = Fixture::new("COLLECTION", json!(0), json!(0));
+ fixture.results.insert(
+ "ALL_COLL_TYPES",
+ Ok(query_result(
+ &[
+ "OWNER",
+ "TYPE_NAME",
+ "COLL_TYPE",
+ "UPPER_BOUND",
+ "ELEM_TYPE_OWNER",
+ "ELEM_TYPE_NAME",
+ "LENGTH",
+ "NUMBER_PRECISION",
+ "SCALE",
+ ],
+ vec![vec![
+ json!(fixture.schema),
+ json!(fixture.name),
+ json!("TABLE"),
+ json!(bound),
+ Value::Null,
+ json!(element),
+ json!(length),
+ json!(precision),
+ json!(scale),
+ ]],
+ )),
+ );
+ let metadata = fixture.read(Dialect::OceanBase).await.unwrap().oracle_metadata.unwrap();
+ let collection = metadata.collection.unwrap();
+ assert_eq!(collection.kind.as_deref(), Some(expected_kind));
+ assert_eq!(collection.upper_bound, expected_bound);
+ assert_eq!(collection.precision, None);
+ assert_eq!(collection.scale, None);
+ assert_eq!(collection.length, if element == "VARCHAR2" { Some(30) } else { None });
+ assert_eq!(metadata.collection_read.state, TypeMetadataState::Available);
+ }
+ }
+
+ #[tokio::test]
+ async fn partial_permission_failure_preserves_other_sections_and_the_reason() {
+ let mut fixture = Fixture::new("COLLECTION", json!(0), json!(0));
+ fixture.results.insert("ALL_TYPE_ATTRS", Err("ORA-01031: insufficient privileges".to_string()));
+ fixture.results.insert(
+ "ALL_COLL_TYPES",
+ Ok(query_result(
+ &[
+ "OWNER",
+ "TYPE_NAME",
+ "COLL_TYPE",
+ "ELEM_TYPE_NAME",
+ "UPPER_BOUND",
+ "PRECISION",
+ "SCALE",
+ "ELEM_TYPE_OWNER",
+ "LENGTH",
+ ],
+ vec![vec![
+ json!(fixture.schema),
+ json!(fixture.name),
+ json!("VARYING ARRAY"),
+ json!("NUMBER"),
+ json!(10),
+ json!(8),
+ json!(2),
+ Value::Null,
+ Value::Null,
+ ]],
+ )),
+ );
+ let metadata = fixture.read(Dialect::Oracle).await.unwrap().oracle_metadata.unwrap();
+ assert_eq!(metadata.attributes_read.state, TypeMetadataState::Unavailable);
+ assert!(metadata.attributes_read.reason.unwrap().contains("ORA-01031"));
+ assert_eq!(metadata.properties_read.state, TypeMetadataState::Available);
+ assert_eq!(metadata.collection_read.state, TypeMetadataState::Available);
+ let collection = metadata.collection.unwrap();
+ assert_eq!(collection.upper_bound, Some(10));
+ assert_eq!(collection.precision, Some(8));
+ assert_eq!(metadata.methods_read.state, TypeMetadataState::Available);
+ }
+
+ #[tokio::test]
+ async fn missing_dm_columns_and_unknown_counts_are_not_complete_empty_metadata() {
+ let mut fixture = Fixture::new("RECORD", Value::Null, Value::Null);
+ fixture.results.insert("ALL_TYPE_ATTRS", Ok(query_result(&["OWNER", "TYPE_NAME", "ATTR_NAME"], vec![])));
+ let details = fixture.read(Dialect::Dameng).await.unwrap();
+ assert_eq!(details.kind, CustomTypeKind::Other);
+ let metadata = details.oracle_metadata.unwrap();
+ assert_eq!(metadata.type_code.as_deref(), Some("RECORD"));
+ assert_eq!(metadata.attribute_count, None);
+ assert_eq!(metadata.attributes_read.state, TypeMetadataState::Incomplete);
+ let reason = metadata.attributes_read.reason.unwrap();
+ assert!(reason.contains("ATTR_NO") && reason.contains("unknown"), "{reason}");
+ assert_eq!(metadata.methods_read.state, TypeMetadataState::Incomplete);
+ }
+
+ #[tokio::test]
+ async fn truncated_rows_are_retained_but_never_declared_complete() {
+ let mut fixture = Fixture::new("OBJECT", json!(0), json!(0));
+ let mut result = query_result(
+ &["OWNER", "TYPE_NAME", "ATTR_NAME", "ATTR_NO", "ATTR_TYPE_NAME"],
+ vec![vec![json!(fixture.schema), json!(fixture.name), json!("ID"), json!(1), json!("NUMBER")]],
+ );
+ result.has_more = true;
+ fixture.results.insert("ALL_TYPE_ATTRS", Ok(result));
+ let metadata = fixture.read(Dialect::Oracle).await.unwrap().oracle_metadata.unwrap();
+ assert_eq!(metadata.attributes.len(), 1);
+ assert_eq!(metadata.attributes_read.state, TypeMetadataState::Incomplete);
+ assert!(metadata.attributes_read.reason.unwrap().contains("truncated"));
+ }
+
+ #[tokio::test]
+ async fn a_body_only_identity_cannot_be_returned_as_a_type() {
+ let mut fixture = Fixture::new("OBJECT", json!(0), json!(0));
+ fixture.results.get_mut("ALL_OBJECTS").unwrap().as_mut().unwrap().rows.remove(0);
+ fixture.results.get_mut("ALL_TYPES").unwrap().as_mut().unwrap().rows.clear();
+ let error = fixture.read(Dialect::Oracle).await.unwrap_err();
+ assert!(error.contains("not found or is not visible"));
+ }
+
+ #[tokio::test]
+ async fn inaccessible_pairing_is_unknown_not_no_body() {
+ let mut fixture = Fixture::new("OBJECT", json!(0), json!(0));
+ fixture.results.insert("ALL_OBJECTS", Err("catalog read failed".into()));
+ let metadata = fixture.read(Dialect::Oracle).await.unwrap().oracle_metadata.unwrap();
+ assert_eq!(metadata.body_visible, None);
+ assert_eq!(metadata.body_read.state, TypeMetadataState::Unavailable);
+ assert_eq!(metadata.status, None);
+ assert_eq!(metadata.properties_read.state, TypeMetadataState::Incomplete);
+ }
+
+ #[tokio::test]
+ async fn methods_attach_parameters_and_results_by_overload_and_check_counts() {
+ let mut fixture = Fixture::new("OBJECT", json!(0), json!(2));
+ fixture.results.insert(
+ "ALL_TYPE_METHODS",
+ Ok(query_result(
+ &["OWNER", "TYPE_NAME", "METHOD_NAME", "METHOD_NO", "METHOD_TYPE", "PARAMETERS", "RESULTS"],
+ vec![
+ vec![
+ json!(fixture.schema),
+ json!(fixture.name),
+ json!("GET"),
+ json!(1),
+ json!("PUBLIC"),
+ json!(1),
+ json!(1),
+ ],
+ vec![
+ json!(fixture.schema),
+ json!(fixture.name),
+ json!("GET"),
+ json!(2),
+ json!("PUBLIC"),
+ json!(2),
+ json!(0),
+ ],
+ ],
+ )),
+ );
+ fixture.results.insert(
+ "ALL_METHOD_PARAMS",
+ Ok(query_result(
+ &[
+ "OWNER",
+ "TYPE_NAME",
+ "METHOD_NAME",
+ "METHOD_NO",
+ "PARAM_NAME",
+ "PARAM_NO",
+ "PARAM_MODE",
+ "PARAM_TYPE_NAME",
+ "PARAM_TYPE_OWNER",
+ ],
+ vec![vec![
+ json!(fixture.schema),
+ json!(fixture.name),
+ json!("GET"),
+ json!(1),
+ json!("VALUE"),
+ json!(1),
+ json!("IN"),
+ json!("NUMBER"),
+ Value::Null,
+ ]],
+ )),
+ );
+ fixture.results.insert(
+ "ALL_METHOD_RESULTS",
+ Ok(query_result(
+ &["OWNER", "TYPE_NAME", "METHOD_NAME", "METHOD_NO", "RESULT_TYPE_NAME", "RESULT_TYPE_OWNER"],
+ vec![vec![
+ json!(fixture.schema),
+ json!(fixture.name),
+ json!("GET"),
+ json!(1),
+ json!("NUMBER"),
+ Value::Null,
+ ]],
+ )),
+ );
+ let metadata = fixture.read(Dialect::Oracle).await.unwrap().oracle_metadata.unwrap();
+ assert_eq!(metadata.methods.len(), 2);
+ assert_eq!(metadata.methods[0].parameters[0].name.as_deref(), Some("VALUE"));
+ assert_eq!(metadata.methods[0].results[0].type_name.as_deref(), Some("NUMBER"));
+ assert_eq!(metadata.methods[0].parameters_read.state, TypeMetadataState::Available);
+ assert!(metadata.methods[1].parameters.is_empty());
+ assert_eq!(metadata.methods[1].parameters_read.state, TypeMetadataState::Incomplete);
+ assert_eq!(metadata.methods_read.state, TypeMetadataState::Incomplete);
+ }
+}
diff --git a/crates/dbx-core/src/schema/oracle_type_evolution.rs b/crates/dbx-core/src/schema/oracle_type_evolution.rs
new file mode 100644
index 0000000000..78fffec7f6
--- /dev/null
+++ b/crates/dbx-core/src/schema/oracle_type_evolution.rs
@@ -0,0 +1,1047 @@
+//! Oracle 19c native evolution. The database performs the in-place conversion;
+//! this reader proves the finite change, restrictions, phase and stable targets.
+use super::{
+ oracle_type_data::{checked, raw_metadata},
+ oracle_type_management::Rows,
+ sql_string,
+};
+use crate::db::{
+ self, OracleTypeEvolutionManifest, OracleTypeEvolutionRequest, OracleTypeManagementSnapshot, TypeMetadataState,
+};
+use dbx_sql::oracle_type_migration_sql::{build_type_evolution_sql, EvolutionDataType, EvolutionShape};
+use serde_json::{json, Value};
+use std::{
+ collections::{BTreeSet, HashSet},
+ future::Future,
+};
+
+pub(super) async fn read<F, Fut>(
+ input: OracleTypeEvolutionRequest,
+ snapshot: OracleTypeManagementSnapshot,
+ mut run: F,
+) -> Result<OracleTypeEvolutionManifest, String>
+where
+ F: FnMut(String) -> Fut,
+ Fut: Future<Output = Result<db::QueryResult, String>>,
+{
+ if snapshot.target != input.target
+ || snapshot.acting_user.as_deref() != Some(&input.target.owner)
+ || [
+ &snapshot.acting_user_read,
+ &snapshot.dependencies_read,
+ &snapshot.persistent_references_read,
+ &snapshot.privileges_read,
+ ]
+ .iter()
+ .any(|read| read.state != TypeMetadataState::Available)
+ || snapshot.dependencies.iter().any(|edge| edge.referenced_link.is_some())
+ {
+ return Err("Native evolution requires the exact owner session and complete visible local dependencies, references and grants".into());
+ }
+ let target = &input.target;
+ let plan = build_type_evolution_sql(&target.owner, &target.name, &input.source_before, &input.source_after)?;
+ if plan.steps.is_empty() {
+ return Err("The specification contains no supported native structural change; keep the current definition or revise the structural draft".into());
+ }
+ let statements: Vec<_> = plan.steps.iter().map(|step| step.sql.clone()).collect();
+ if let Some(previous) = &input.manifest {
+ if previous.target != *target
+ || previous.source_before != input.source_before
+ || previous.source_after != input.source_after
+ || previous.statements != statements
+ || previous.phase > statements.len()
+ {
+ return Err("The original native evolution target, definitions or phase record changed".into());
+ }
+ }
+ let version = Rows::new(
+ run("SELECT VERSION FROM PRODUCT_COMPONENT_VERSION WHERE PRODUCT LIKE 'Oracle Database%'".into()).await,
+ &["VERSION"],
+ );
+ checked(&version)?;
+ if version.rows.len() != 1 || !text(&version, &version.rows[0], "VERSION")?.starts_with("19.") {
+ return Err("This bounded native evolution route requires verified Oracle Database 19c metadata".into());
+ }
+ let root = snapshot
+ .objects
+ .iter()
+ .find(|object| object.owner == target.owner && object.name == target.name && object.object_type == "TYPE")
+ .ok_or("The original TYPE identity is missing")?;
+ if root.exists != Some(true)
+ || root.status.as_deref() != Some("VALID")
+ || !root.errors.is_empty()
+ || [&root.status_read, &root.source_read, &root.errors_read]
+ .iter()
+ .any(|read| read.state != TypeMetadataState::Available)
+ {
+ return Err(
+ "Read back the complete valid TYPE specification and compilation state before native evolution".into()
+ );
+ }
+ let actual_source = root.source.as_deref().ok_or("The complete current TYPE source is missing")?;
+ // Native DDL may leave a previous source rendering. Both the immutable
+ // signature and any rendered structural changes must still be approved;
+ // the current stage itself is proved by the actual attribute dictionary.
+ let rendered = build_type_evolution_sql(&target.owner, &target.name, &input.source_before, actual_source)?;
+ if rendered.steps.iter().any(|step| !statements.contains(&step.sql)) {
+ return Err("The live TYPE source contains a structural change outside the approved native phases".into());
+ }
+ let mut types: BTreeSet<_> = snapshot
+ .objects
+ .iter()
+ .filter(|object| object.object_type == "TYPE" && object.exists == Some(true))
+ .map(|object| (object.owner.clone(), object.name.clone()))
+ .collect();
+ types.insert((target.owner.clone(), target.name.clone()));
+ let mut metadata = vec![raw_metadata(&version)];
+ let mut phase = None;
+ let mut varray_types = BTreeSet::new();
+ for (owner, name) in &types {
+ if owner != &target.owner {
+ return Err("A cross-owner dependent TYPE needs its own verified evolution plan".into());
+ }
+ let is_root = name == &target.name;
+ let state = type_state(owner, name, &mut run).await?;
+ if state
+ .collection
+ .as_ref()
+ .is_some_and(|rows| rows.text(&rows.rows[0], "COLL_TYPE").as_deref() == Some("VARYING ARRAY"))
+ {
+ varray_types.insert((owner.clone(), name.clone()));
+ }
+ if is_root {
+ for (index, shape) in
+ std::iter::once(&plan.before).chain(plan.steps.iter().map(|step| &step.after)).enumerate()
+ {
+ if state.matches(shape)? && phase.replace(index).is_some() {
+ return Err("The native evolution phase is ambiguous".into());
+ }
+ }
+ }
+ metadata.push(json!([owner, name, state.fixed(is_root)]));
+ }
+ let phase = phase.ok_or("The actual TYPE dictionary does not match an approved native evolution phase")?;
+ if input.manifest.is_none() && phase != 0 {
+ return Err(
+ "Register native guards before the first structural change; do not adopt a new original baseline".into()
+ );
+ }
+ if phase == 0 {
+ use dbx_sql::object_source_sql::{build_oracle_type_management_source, EditableObjectSourceSqlInput};
+ let fingerprint = |source: &str| {
+ build_oracle_type_management_source(EditableObjectSourceSqlInput {
+ database_type: super::DatabaseType::Oracle,
+ object_type: db::ObjectSourceKind::Type,
+ schema: Some(target.owner.clone()),
+ name: target.name.clone(),
+ source: source.into(),
+ })
+ .map(|(_, fingerprint)| fingerprint)
+ };
+ if fingerprint(actual_source)? != fingerprint(&input.source_before)? {
+ return Err("The original native TYPE definition changed before dispatch".into());
+ }
+ }
+ let mut tables: BTreeSet<_> =
+ snapshot.persistent_references.iter().map(|r| (r.owner.clone(), r.table_name.clone())).collect();
+ tables.extend(
+ snapshot
+ .dependencies
+ .iter()
+ .filter(|edge| edge.object_type == "TABLE")
+ .map(|edge| (edge.owner.clone(), edge.name.clone())),
+ );
+ for (owner, name) in tables {
+ if owner != target.owner {
+ return Err("A cross-owner stored table needs its own verified preparation plan".into());
+ }
+ metadata.push(table_guard(&owner, &name, &varray_types, &snapshot, &mut run).await?);
+ }
+ let mut edges: Vec<_> = snapshot
+ .dependencies
+ .iter()
+ .filter(|edge| ["TYPE", "TABLE"].contains(&edge.object_type.as_str()))
+ .map(|edge| serde_json::to_string(edge).map_err(|e| e.to_string()))
+ .collect::<Result<_, _>>()?;
+ edges.sort();
+ metadata.push(json!(edges));
+ let mut refs: Vec<_> = snapshot
+ .persistent_references
+ .iter()
+ .map(|r| serde_json::to_string(r).map_err(|e| e.to_string()))
+ .collect::<Result<_, _>>()?;
+ refs.sort();
+ metadata.push(json!(refs));
+ let mut type_grants = Vec::new();
+ for object in snapshot.objects.iter().filter(|object| object.object_type == "TYPE" && object.exists == Some(true)) {
+ if object.privileges_read.state != TypeMetadataState::Available {
+ return Err("Read the complete direct TYPE grants before native evolution".into());
+ }
+ let mut grants: Vec<_> = object
+ .direct_privileges
+ .iter()
+ .map(|g| serde_json::to_string(g).map_err(|e| e.to_string()))
+ .collect::<Result<_, _>>()?;
+ grants.sort();
+ type_grants.push(json!([object.owner, object.name, grants]));
+ }
+ type_grants.sort_by_key(Value::to_string);
+ metadata.push(json!(type_grants));
+ let metadata = serde_json::to_string(&metadata).map_err(|e| e.to_string())?;
+ if input.manifest.as_ref().is_some_and(|original| original.metadata != metadata) {
+ return Err("The native evolution table identity, row count, grants or restrictions changed. Keep the original guards and reconcile the actual objects".into());
+ }
+ Ok(OracleTypeEvolutionManifest {
+ target: input.target,
+ source_before: input.source_before,
+ source_after: input.source_after,
+ statements,
+ metadata,
+ phase,
+ })
+}
+
+fn text(rows: &Rows, row: &[Value], name: &str) -> Result<String, String> {
+ rows.text(row, name).ok_or_else(|| format!("Native evolution cannot verify {name}"))
+}
+fn dimension(rows: &Rows, row: &[Value], name: &str) -> Result<Option<i32>, String> {
+ rows.value(row, name)
+ .map(|_| text(rows, row, name)?.parse::<i32>().map_err(|_| format!("Native evolution has unknown {name}")))
+ .transpose()
+}
+fn exact_type(rows: &Rows, row: &[Value], prefix: &str, expected: &EvolutionDataType) -> Result<bool, String> {
+ if rows.value(row, &format!("{prefix}_TYPE_MOD")).is_some() {
+ return Ok(false);
+ }
+ let owner = rows.text(row, &format!("{prefix}_TYPE_OWNER"));
+ let name = text(rows, row, &format!("{prefix}_TYPE_NAME"))?;
+ Ok(match expected {
+ EvolutionDataType::Named { owner: expected_owner, name: expected_name } => {
+ owner.as_ref() == Some(expected_owner) && name == *expected_name
+ }
+ EvolutionDataType::Scalar(ty) if owner.is_none() && name == ty.name => match ty.name.as_str() {
+ "NUMBER" => dimension(rows, row, "PRECISION")? == ty.size && dimension(rows, row, "SCALE")? == ty.scale,
+ "VARCHAR2" => {
+ rows.text(row, "CHAR_USED").as_deref() == Some("B")
+ && ty.semantics.as_deref().is_none_or(|s| s == "BYTE")
+ && dimension(rows, row, "LENGTH")? == ty.size
+ }
+ "RAW" => dimension(rows, row, "LENGTH")? == ty.size,
+ "DATE" => true,
+ _ => false,
+ },
+ _ => false,
+ })
+}
+struct TypeState {
+ identity: Rows,
+ properties: Rows,
+ attributes: Rows,
+ collection: Option<Rows>,
+ methods: Rows,
+ parameters: Rows,
+ results: Rows,
+}
+impl TypeState {
+ fn matches(&self, shape: &EvolutionShape) -> Result<bool, String> {
+ if let Some((limit, element)) = &shape.varray {
+ let Some(collection) = &self.collection else { return Ok(false) };
+ return Ok(collection.rows.len() == 1
+ && collection.text(&collection.rows[0], "COLL_TYPE").as_deref() == Some("VARYING ARRAY")
+ && dimension(collection, &collection.rows[0], "UPPER_BOUND")? == Some(*limit)
+ && exact_type(collection, &collection.rows[0], "ELEM", element)?);
+ }
+ if self.collection.is_some() || self.attributes.rows.len() != shape.attributes.len() {
+ return Ok(false);
+ }
+ for (index, ((name, ty), row)) in shape.attributes.iter().zip(&self.attributes.rows).enumerate() {
+ if self.attributes.text(row, "ATTR_NAME").as_deref() != Some(name)
+ || dimension(&self.attributes, row, "ATTR_NO")? != Some(index as i32 + 1)
+ || self.attributes.yes_no(row, "INHERITED") != Some(false)
+ || !exact_type(&self.attributes, row, "ATTR", ty)?
+ {
+ return Ok(false);
+ }
+ }
+ Ok(true)
+ }
+ fn fixed(&self, root: bool) -> Value {
+ let properties: Vec<_> = self
+ .properties
+ .columns
+ .iter()
+ .enumerate()
+ .filter(|(_, name)| !root || !name.eq_ignore_ascii_case("ATTRIBUTES"))
+ .map(|(index, name)| (name, self.properties.rows[0][index].clone()))
+ .collect();
+ json!([
+ raw_metadata(&self.identity),
+ properties,
+ if root { Value::Null } else { raw_metadata(&self.attributes) },
+ if root { Value::Null } else { self.collection.as_ref().map(raw_metadata).unwrap_or(Value::Null) },
+ raw_metadata(&self.methods),
+ raw_metadata(&self.parameters),
+ raw_metadata(&self.results)
+ ])
+ }
+}
+async fn type_state<F, Fut>(owner: &str, name: &str, run: &mut F) -> Result<TypeState, String>
+where
+ F: FnMut(String) -> Fut,
+ Fut: Future<Output = Result<db::QueryResult, String>>,
+{
+ let predicate = format!("OWNER={} AND TYPE_NAME={}", sql_string(owner), sql_string(name));
+ let identity = object_identity(owner, name, "TYPE", run).await?;
+ let properties=Rows::new(run(format!("SELECT TYPECODE, ATTRIBUTES, METHODS, FINAL, INSTANTIABLE, PREDEFINED, INCOMPLETE, SUPERTYPE_OWNER, SUPERTYPE_NAME FROM ALL_TYPES WHERE {predicate}")).await,&["TYPECODE","ATTRIBUTES","METHODS","FINAL","INSTANTIABLE","PREDEFINED","INCOMPLETE","SUPERTYPE_OWNER","SUPERTYPE_NAME"]);
+ checked(&properties)?;
+ if properties.rows.len() != 1 {
+ return Err("The complete native TYPE identity could not be read".into());
+ }
+ let row = &properties.rows[0];
+ let kind = text(&properties, row, "TYPECODE")?;
+ if !["OBJECT", "COLLECTION"].contains(&kind.as_str())
+ || properties.yes_no(row, "PREDEFINED") != Some(false)
+ || properties.yes_no(row, "INCOMPLETE") != Some(false)
+ || properties.value(row, "SUPERTYPE_OWNER").is_some()
+ || properties.value(row, "SUPERTYPE_NAME").is_some()
+ || (kind == "OBJECT"
+ && (properties.yes_no(row, "FINAL") != Some(true) || properties.yes_no(row, "INSTANTIABLE") != Some(true)))
+ {
+ return Err("Native evolution needs complete final non-inherited user types; inheritance or unknown type properties require preparation".into());
+ }
+ let attributes=Rows::new(run(format!("SELECT ATTR_NAME, ATTR_NO, ATTR_TYPE_MOD, ATTR_TYPE_OWNER, ATTR_TYPE_NAME, LENGTH, PRECISION, SCALE, CHAR_USED, INHERITED FROM ALL_TYPE_ATTRS WHERE {predicate} ORDER BY ATTR_NO")).await,&["ATTR_NAME","ATTR_NO","ATTR_TYPE_MOD","ATTR_TYPE_OWNER","ATTR_TYPE_NAME","LENGTH","PRECISION","SCALE","CHAR_USED","INHERITED"]);
+ checked(&attributes)?;
+ if dimension(&properties, row, "ATTRIBUTES")? != Some(attributes.rows.len() as i32) {
+ return Err("The native attribute dictionary is incomplete".into());
+ }
+ let collection = if kind == "COLLECTION" {
+ let rows=Rows::new(run(format!("SELECT COLL_TYPE, UPPER_BOUND, ELEM_TYPE_MOD, ELEM_TYPE_OWNER, ELEM_TYPE_NAME, LENGTH, PRECISION, SCALE, CHAR_USED FROM ALL_COLL_TYPES WHERE {predicate}")).await,&["COLL_TYPE","UPPER_BOUND","ELEM_TYPE_MOD","ELEM_TYPE_OWNER","ELEM_TYPE_NAME","LENGTH","PRECISION","SCALE","CHAR_USED"]);
+ checked(&rows)?;
+ if rows.rows.len() != 1 {
+ return Err("The complete collection definition is unknown".into());
+ }
+ Some(rows)
+ } else {
+ None
+ };
+ let methods = Rows::new(
+ run(format!("SELECT * FROM ALL_TYPE_METHODS WHERE {predicate}")).await,
+ &[
+ "METHOD_NAME",
+ "METHOD_NO",
+ "METHOD_TYPE",
+ "PARAMETERS",
+ "RESULTS",
+ "FINAL",
+ "INSTANTIABLE",
+ "OVERRIDING",
+ "INHERITED",
+ ],
+ );
+ checked(&methods)?;
+ let parameters = Rows::new(
+ run(format!("SELECT * FROM ALL_METHOD_PARAMS WHERE {predicate}")).await,
+ &["METHOD_NAME", "METHOD_NO", "PARAM_NAME", "PARAM_NO", "PARAM_MODE", "PARAM_TYPE_OWNER", "PARAM_TYPE_NAME"],
+ );
+ checked(&parameters)?;
+ let results = Rows::new(
+ run(format!("SELECT * FROM ALL_METHOD_RESULTS WHERE {predicate}")).await,
+ &["METHOD_NAME", "METHOD_NO", "RESULT_TYPE_OWNER", "RESULT_TYPE_NAME"],
+ );
+ checked(&results)?;
+ if dimension(&properties, row, "METHODS")? != Some(methods.rows.len() as i32) {
+ return Err("The native method dictionary is incomplete".into());
+ }
+ let method_key = |rows: &Rows, row: &[Value]| -> Result<_, String> {
+ Ok((text(rows, row, "METHOD_NAME")?, dimension(rows, row, "METHOD_NO")?.ok_or("Unknown method number")?))
+ };
+ let mut method_keys = HashSet::new();
+ for row in &methods.rows {
+ let key = method_key(&methods, row)?;
+ if !method_keys.insert(key.clone()) {
+ return Err("The native method identity is ambiguous".into());
+ }
+ for (rows, column) in [(&parameters, "PARAMETERS"), (&results, "RESULTS")] {
+ let count = rows.rows.iter().filter(|row| method_key(rows, row).as_ref() == Ok(&key)).count();
+ if dimension(&methods, row, column)? != Some(count as i32) {
+ return Err("The complete native method signatures could not be verified".into());
+ }
+ }
+ }
+ let mut parameters_seen = HashSet::new();
+ let mut results_seen = HashSet::new();
+ for row in &parameters.rows {
+ let key = method_key(&parameters, row)?;
+ if !method_keys.contains(&key)
+ || !parameters_seen
+ .insert((key, dimension(&parameters, row, "PARAM_NO")?.ok_or("Unknown parameter position")?))
+ {
+ return Err("The native parameter list has an unknown or repeated identity".into());
+ }
+ text(&parameters, row, "PARAM_MODE")?;
+ text(&parameters, row, "PARAM_TYPE_NAME")?;
+ }
+ for row in &results.rows {
+ let key = method_key(&results, row)?;
+ if !method_keys.contains(&key) || !results_seen.insert(key) {
+ return Err("The native result signature has an unknown or repeated identity".into());
+ }
+ text(&results, row, "RESULT_TYPE_NAME")?;
+ }
+ Ok(TypeState { identity, properties, attributes, collection, methods, parameters, results })
+}
+async fn object_identity<F, Fut>(owner: &str, name: &str, kind: &str, run: &mut F) -> Result<Rows, String>
+where
+ F: FnMut(String) -> Fut,
+ Fut: Future<Output = Result<db::QueryResult, String>>,
+{
+ let rows=Rows::new(run(format!("SELECT TO_CHAR(OBJECT_ID) AS OBJECT_ID, EDITION_NAME, ORACLE_MAINTAINED FROM ALL_OBJECTS WHERE OWNER={} AND OBJECT_NAME={} AND OBJECT_TYPE={} AND SUBOBJECT_NAME IS NULL",sql_string(owner),sql_string(name),sql_string(kind))).await,&["OBJECT_ID","EDITION_NAME","ORACLE_MAINTAINED"]);
+ checked(&rows)?;
+ if rows.rows.len() != 1
+ || rows.value(&rows.rows[0], "OBJECT_ID").is_none()
+ || rows.value(&rows.rows[0], "EDITION_NAME").is_some()
+ || rows.yes_no(&rows.rows[0], "ORACLE_MAINTAINED") != Some(false)
+ {
+ return Err("The exact non-editioned, non-system object identity is not verified".into());
+ }
+ Ok(rows)
+}
+async fn table_guard<F, Fut>(
+ owner: &str,
+ name: &str,
+ varray_types: &BTreeSet<(String, String)>,
+ snapshot: &OracleTypeManagementSnapshot,
+ run: &mut F,
+) -> Result<Value, String>
+where
+ F: FnMut(String) -> Fut,
+ Fut: Future<Output = Result<db::QueryResult, String>>,
+{
+ let predicate = format!("OWNER={} AND TABLE_NAME={}", sql_string(owner), sql_string(name));
+ let identity = object_identity(owner, name, "TABLE", run).await?;
+ let tables=Rows::new(run(format!("SELECT TABLE_NAME, TEMPORARY, NESTED, IOT_TYPE, CLUSTER_NAME, PARTITIONED, READ_ONLY, STATUS, TABLESPACE_NAME FROM ALL_TABLES WHERE {predicate}")).await,&["TABLE_NAME","TEMPORARY","NESTED","IOT_TYPE","CLUSTER_NAME","PARTITIONED","READ_ONLY","STATUS","TABLESPACE_NAME"]);
+ checked(&tables)?;
+ if tables.rows.len() != 1 {
+ return Err("The stored table identity is unknown".into());
+ }
+ let row = &tables.rows[0];
+ if tables.yes_no(row, "TEMPORARY") != Some(false)
+ || tables.yes_no(row, "NESTED") != Some(false)
+ || tables.yes_no(row, "PARTITIONED") != Some(false)
+ || tables.yes_no(row, "READ_ONLY") != Some(false)
+ || tables.value(row, "IOT_TYPE").is_some()
+ || tables.value(row, "CLUSTER_NAME").is_some()
+ || tables.text(row, "STATUS").as_deref() != Some("VALID")
+ {
+ return Err(format!("{owner}.{name}: partitioned, clustered, IOT, nested, temporary, read-only or unknown tables need explicit preparation"));
+ }
+ for catalogue in ["ALL_EXTERNAL_TABLES", "ALL_OBJECT_TABLES"] {
+ let rows =
+ Rows::new(run(format!("SELECT TABLE_NAME FROM {catalogue} WHERE {predicate}")).await, &["TABLE_NAME"]);
+ checked(&rows)?;
+ if !rows.rows.is_empty() {
+ return Err("External and object tables need explicit verified preparation".into());
+ }
+ }
+ let columns = Rows::new(
+ run(format!("SELECT * FROM ALL_TAB_COLS WHERE {predicate} ORDER BY COLUMN_ID")).await,
+ &[
+ "COLUMN_NAME",
+ "COLUMN_ID",
+ "DATA_TYPE_OWNER",
+ "DATA_TYPE",
+ "DATA_LENGTH",
+ "DATA_PRECISION",
+ "DATA_SCALE",
+ "CHAR_USED",
+ "CHAR_LENGTH",
+ "NULLABLE",
+ "HIDDEN_COLUMN",
+ "USER_GENERATED",
+ "VIRTUAL_COLUMN",
+ ],
+ );
+ checked(&columns)?;
+ let mut user_columns = Vec::new();
+ let mut names = HashSet::new();
+ for row in &columns.rows {
+ if columns.yes_no(row, "HIDDEN_COLUMN") == Some(true) && columns.yes_no(row, "USER_GENERATED") == Some(false) {
+ continue;
+ }
+ if columns.yes_no(row, "HIDDEN_COLUMN").is_none()
+ || columns.yes_no(row, "USER_GENERATED") != Some(true)
+ || columns.yes_no(row, "VIRTUAL_COLUMN") != Some(false)
+ {
+ return Err("Unknown or virtual stored columns need explicit preparation".into());
+ }
+ let name = text(&columns, row, "COLUMN_NAME")?;
+ if !names.insert(name.clone()) {
+ return Err("The stored column identity is ambiguous".into());
+ }
+ let user_type = columns.value(row, "DATA_TYPE_OWNER").is_some();
+ let definition: Vec<_> = columns
+ .columns
+ .iter()
+ .enumerate()
+ .filter(|(_, name)| {
+ [
+ "COLUMN_NAME",
+ "COLUMN_ID",
+ "DATA_TYPE_OWNER",
+ "DATA_TYPE",
+ "NULLABLE",
+ "HIDDEN_COLUMN",
+ "USER_GENERATED",
+ "VIRTUAL_COLUMN",
+ "DATA_DEFAULT",
+ "DEFAULT_ON_NULL",
+ "IDENTITY_COLUMN",
+ "COLLATION",
+ ]
+ .iter()
+ .any(|wanted| name.eq_ignore_ascii_case(wanted))
+ || (!user_type
+ && ["DATA_LENGTH", "DATA_PRECISION", "DATA_SCALE", "CHAR_USED", "CHAR_LENGTH"]
+ .iter()
+ .any(|wanted| name.eq_ignore_ascii_case(wanted)))
+ })
+ .map(|(index, name)| (name, row[index].clone()))
+ .collect();
+ user_columns.push(json!(definition));
+ }
+ if user_columns.is_empty() {
+ return Err("The complete stored-column definition is missing".into());
+ }
+ for reference in snapshot.persistent_references.iter().filter(|r| r.owner == owner && r.table_name == name) {
+ let column = reference.column_name.as_deref().ok_or("The exact stored UDT column is unknown")?;
+ if !columns.rows.iter().any(|row| {
+ columns.text(row, "COLUMN_NAME").as_deref() == Some(column)
+ && columns.text(row, "DATA_TYPE_OWNER") == reference.data_type_owner
+ && columns.text(row, "DATA_TYPE") == reference.data_type
+ }) {
+ return Err("The registered stored UDT reference changed".into());
+ }
+ }
+ let indexes = Rows::new(
+ run(format!(
+ "SELECT INDEX_NAME, INDEX_TYPE, STATUS FROM ALL_INDEXES WHERE TABLE_OWNER={} AND TABLE_NAME={}",
+ sql_string(owner),
+ sql_string(name)
+ ))
+ .await,
+ &["INDEX_NAME", "INDEX_TYPE", "STATUS"],
+ );
+ checked(&indexes)?;
+ for row in &indexes.rows {
+ if !matches!(indexes.text(row, "INDEX_TYPE").as_deref(), Some("NORMAL" | "NORMAL/REV" | "BITMAP" | "LOB"))
+ || indexes.text(row, "STATUS").as_deref() != Some("VALID")
+ {
+ return Err(
+ "A function/domain, unusable or unknown attribute index requires a separate verified plan".into()
+ );
+ }
+ }
+ let indexed_columns=Rows::new(run(format!("SELECT INDEX_NAME, COLUMN_NAME, COLUMN_POSITION FROM ALL_IND_COLUMNS WHERE TABLE_OWNER={} AND TABLE_NAME={}",sql_string(owner),sql_string(name))).await,&["INDEX_NAME","COLUMN_NAME","COLUMN_POSITION"]);
+ checked(&indexed_columns)?;
+ let varrays = Rows::new(
+ run(format!(
+ "SELECT TYPE_OWNER, TYPE_NAME, LOB_NAME FROM ALL_VARRAYS WHERE OWNER={} AND PARENT_TABLE_NAME={}",
+ sql_string(owner),
+ sql_string(name)
+ ))
+ .await,
+ &["TYPE_OWNER", "TYPE_NAME", "LOB_NAME"],
+ );
+ checked(&varrays)?;
+ let mut needed_varrays = BTreeSet::new();
+ let mut seen = HashSet::new();
+ let mut pending: Vec<_> = snapshot
+ .persistent_references
+ .iter()
+ .filter(|r| r.owner == owner && r.table_name == name)
+ .filter_map(|r| Some((r.data_type_owner.clone()?, r.data_type.clone()?)))
+ .collect();
+ while let Some(key) = pending.pop() {
+ if !seen.insert(key.clone()) {
+ continue;
+ }
+ if varray_types.contains(&key) {
+ needed_varrays.insert(key.clone());
+ }
+ pending.extend(
+ snapshot
+ .dependencies
+ .iter()
+ .filter(|edge| {
+ edge.object_type == "TYPE"
+ && edge.owner == key.0
+ && edge.name == key.1
+ && edge.referenced_type == "TYPE"
+ })
+ .map(|edge| (edge.referenced_owner.clone(), edge.referenced_name.clone())),
+ );
+ }
+ for key in &needed_varrays {
+ if !varrays.rows.iter().any(|row| {
+ varrays.text(row, "TYPE_OWNER").as_ref() == Some(&key.0)
+ && varrays.text(row, "TYPE_NAME").as_ref() == Some(&key.1)
+ }) {
+ return Err("The complete affected VARRAY storage definition is unavailable".into());
+ }
+ }
+ for row in &varrays.rows {
+ if needed_varrays.contains(&(text(&varrays, row, "TYPE_OWNER")?, text(&varrays, row, "TYPE_NAME")?))
+ && varrays.value(row, "LOB_NAME").is_none()
+ {
+ return Err("An inline VARRAY may require a physical LOB storage transition; prepare that storage explicitly before native evolution".into());
+ }
+ }
+ let lobs = Rows::new(
+ run(format!("SELECT SEGMENT_NAME, TABLESPACE_NAME, COLUMN_NAME FROM ALL_LOBS WHERE {predicate}")).await,
+ &["SEGMENT_NAME", "TABLESPACE_NAME", "COLUMN_NAME"],
+ );
+ checked(&lobs)?;
+ for row in &varrays.rows {
+ if needed_varrays.contains(&(text(&varrays, row, "TYPE_OWNER")?, text(&varrays, row, "TYPE_NAME")?))
+ && !lobs.rows.iter().any(|lob| lobs.text(lob, "SEGMENT_NAME") == varrays.text(row, "LOB_NAME"))
+ {
+ return Err("The affected VARRAY LOB and its tablespace could not be verified".into());
+ }
+ }
+ let mut spaces = BTreeSet::from([text(&tables, &tables.rows[0], "TABLESPACE_NAME")?]);
+ for row in &lobs.rows {
+ spaces.insert(text(&lobs, row, "TABLESPACE_NAME")?);
+ }
+ let spaces = Rows::new(
+ run(format!(
+ "SELECT TABLESPACE_NAME, STATUS FROM USER_TABLESPACES WHERE TABLESPACE_NAME IN ({})",
+ spaces.iter().map(|name| sql_string(name)).collect::<Vec<_>>().join(", ")
+ ))
+ .await,
+ &["TABLESPACE_NAME", "STATUS"],
+ );
+ checked(&spaces)?;
+ if spaces.rows.is_empty() || spaces.rows.iter().any(|row| spaces.text(row, "STATUS").as_deref() != Some("ONLINE")) {
+ return Err("Every data/LOB tablespace must have a verified read/write ONLINE state".into());
+ }
+ let required_spaces: BTreeSet<_> = std::iter::once(text(&tables, &tables.rows[0], "TABLESPACE_NAME")?)
+ .chain(lobs.rows.iter().map(|row| text(&lobs, row, "TABLESPACE_NAME")).collect::<Result<Vec<_>, _>>()?)
+ .collect();
+ let observed_spaces: BTreeSet<_> =
+ spaces.rows.iter().map(|row| text(&spaces, row, "TABLESPACE_NAME")).collect::<Result<_, _>>()?;
+ if required_spaces != observed_spaces || spaces.rows.len() != required_spaces.len() {
+ return Err("A required data/LOB tablespace state is missing or ambiguous".into());
+ }
+ let count = Rows::new(
+ run(format!(
+ "SELECT TO_CHAR(COUNT(*)) AS ROW_COUNT FROM \"{}\".\"{}\"",
+ owner.replace('"', "\"\""),
+ name.replace('"', "\"\"")
+ ))
+ .await,
+ &["ROW_COUNT"],
+ );
+ checked(&count)?;
+ if count.rows.len() != 1 || !text(&count, &count.rows[0], "ROW_COUNT")?.bytes().all(|b| b.is_ascii_digit()) {
+ return Err("The complete native table row count is unknown".into());
+ }
+ let grants = Rows::new(
+ run(format!(
+ "SELECT * FROM ALL_TAB_PRIVS WHERE TABLE_SCHEMA={} AND TABLE_NAME={}",
+ sql_string(owner),
+ sql_string(name)
+ ))
+ .await,
+ &["TABLE_NAME", "GRANTEE", "GRANTOR", "PRIVILEGE", "GRANTABLE"],
+ );
+ checked(&grants)?;
+ Ok(json!([
+ owner,
+ name,
+ raw_metadata(&identity),
+ raw_metadata(&tables),
+ user_columns,
+ raw_metadata(&indexes),
+ raw_metadata(&indexed_columns),
+ raw_metadata(&varrays),
+ raw_metadata(&lobs),
+ raw_metadata(&spaces),
+ raw_metadata(&count),
+ raw_metadata(&grants)
+ ]))
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use std::{cell::RefCell, rc::Rc};
+ const BEFORE: &str = "CREATE OR REPLACE TYPE APP.ROOT AS OBJECT (ID NUMBER(8,0));";
+ const AFTER: &str = "CREATE OR REPLACE TYPE APP.ROOT AS OBJECT (ID NUMBER(10,0), EXTRA RAW(16));";
+
+ #[derive(Default)]
+ struct Fixture {
+ phase: usize,
+ forbidden: Option<&'static str>,
+ table_id: &'static str,
+ rows: u32,
+ varray: bool,
+ }
+ fn result(columns: &[&str], rows: Vec<Vec<Value>>) -> Result<db::QueryResult, String> {
+ Ok(serde_json::from_value(json!({"columns":columns,"rows":rows,"affected_rows":0,"execution_time_ms":0}))
+ .unwrap())
+ }
+ fn request(manifest: Option<OracleTypeEvolutionManifest>) -> OracleTypeEvolutionRequest {
+ OracleTypeEvolutionRequest {
+ target: db::OracleTypeManagementTarget {
+ connection_id: "native".into(),
+ database: "db".into(),
+ owner: "APP".into(),
+ name: "ROOT".into(),
+ },
+ source_before: BEFORE.into(),
+ source_after: AFTER.into(),
+ manifest,
+ }
+ }
+ fn snapshot() -> OracleTypeManagementSnapshot {
+ serde_json::from_value(json!({"target":request(None).target,"visibilityScope":"current-user-visible-dictionaries","actingUser":"APP","actingUserRead":{"state":"available"},"detailsRead":{"state":"available"},"typeSourceRead":{"state":"available"},"bodySourceRead":{"state":"available"},"objects":[{"owner":"APP","name":"ROOT","objectType":"TYPE","exists":true,"objectId":"11","status":"VALID","statusRead":{"state":"available"},"source":BEFORE,"sourceRead":{"state":"available"},"errors":[],"errorsRead":{"state":"available"},"directPrivileges":[],"privilegesRead":{"state":"available"}}],"dependencies":[{"owner":"APP","name":"DATA","objectType":"TABLE","referencedOwner":"APP","referencedName":"ROOT","referencedType":"TYPE","referencedLink":null}],"dependenciesRead":{"state":"available"},"persistentReferences":[{"owner":"APP","tableName":"DATA","columnName":"VALUE","dataTypeOwner":"APP","dataType":"ROOT","tableStatus":"VALID","tableReadOnly":false}],"persistentReferencesRead":{"state":"available"},"directPrivileges":[],"privilegesRead":{"state":"available"}})).unwrap()
+ }
+ fn query(f: &Fixture, sql: &str) -> Result<db::QueryResult, String> {
+ assert!(!sql.contains("DBA_") && !sql.starts_with("ALTER") && !sql.starts_with("DROP"));
+ if f.forbidden == Some("truncated") && sql.contains("ALL_TYPES") {
+ let mut value = result(&["TYPECODE"], vec![])?;
+ value.truncated = true;
+ return Ok(value);
+ }
+ if sql.contains("PRODUCT_COMPONENT_VERSION") {
+ return result(
+ &["VERSION"],
+ vec![vec![json!(if f.forbidden == Some("version") { "12.1.0.2" } else { "19.0.0.0.0" })]],
+ );
+ }
+ if sql.contains("ALL_OBJECTS") {
+ let id = if sql.contains("OBJECT_TYPE='TABLE'") {
+ if f.table_id.is_empty() {
+ "22"
+ } else {
+ f.table_id
+ }
+ } else {
+ "11"
+ };
+ return result(
+ &["OBJECT_ID", "EDITION_NAME", "ORACLE_MAINTAINED"],
+ vec![vec![
+ json!(id),
+ if f.forbidden == Some("edition") { json!("EDITION_X") } else { Value::Null },
+ json!("N"),
+ ]],
+ );
+ }
+ if sql.contains("ALL_TYPES") {
+ return result(
+ &[
+ "TYPECODE",
+ "ATTRIBUTES",
+ "METHODS",
+ "FINAL",
+ "INSTANTIABLE",
+ "PREDEFINED",
+ "INCOMPLETE",
+ "SUPERTYPE_OWNER",
+ "SUPERTYPE_NAME",
+ ],
+ vec![vec![
+ json!(if f.varray { "COLLECTION" } else { "OBJECT" }),
+ json!(if f.varray {
+ 0
+ } else if f.phase == 2 {
+ 2
+ } else {
+ 1
+ }),
+ json!(0),
+ json!(if f.forbidden == Some("inheritance") { "NO" } else { "YES" }),
+ json!("YES"),
+ json!("NO"),
+ json!("NO"),
+ Value::Null,
+ Value::Null,
+ ]],
+ );
+ }
+ if sql.contains("ALL_TYPE_ATTRS") {
+ let mut rows = vec![vec![
+ json!("ID"),
+ json!(1),
+ Value::Null,
+ Value::Null,
+ json!("NUMBER"),
+ Value::Null,
+ json!(if f.phase > 0 { 10 } else { 8 }),
+ json!(0),
+ Value::Null,
+ json!("NO"),
+ ]];
+ if f.phase == 2 {
+ rows.push(vec![
+ json!("EXTRA"),
+ json!(2),
+ Value::Null,
+ Value::Null,
+ json!("RAW"),
+ json!(16),
+ Value::Null,
+ Value::Null,
+ Value::Null,
+ json!("NO"),
+ ]);
+ }
+ return result(
+ &[
+ "ATTR_NAME",
+ "ATTR_NO",
+ "ATTR_TYPE_MOD",
+ "ATTR_TYPE_OWNER",
+ "ATTR_TYPE_NAME",
+ "LENGTH",
+ "PRECISION",
+ "SCALE",
+ "CHAR_USED",
+ "INHERITED",
+ ],
+ if f.varray { vec![] } else { rows },
+ );
+ }
+ if sql.contains("ALL_COLL_TYPES") {
+ return result(
+ &[
+ "COLL_TYPE",
+ "UPPER_BOUND",
+ "ELEM_TYPE_MOD",
+ "ELEM_TYPE_OWNER",
+ "ELEM_TYPE_NAME",
+ "LENGTH",
+ "PRECISION",
+ "SCALE",
+ "CHAR_USED",
+ ],
+ vec![vec![
+ json!("VARYING ARRAY"),
+ json!(if f.phase == 0 { 10 } else { 30 }),
+ Value::Null,
+ Value::Null,
+ json!("NUMBER"),
+ Value::Null,
+ json!(8),
+ json!(0),
+ Value::Null,
+ ]],
+ );
+ }
+ if sql.contains("ALL_TYPE_METHODS") {
+ return result(
+ &[
+ "METHOD_NAME",
+ "METHOD_NO",
+ "METHOD_TYPE",
+ "PARAMETERS",
+ "RESULTS",
+ "FINAL",
+ "INSTANTIABLE",
+ "OVERRIDING",
+ "INHERITED",
+ ],
+ vec![],
+ );
+ }
+ if sql.contains("ALL_METHOD_PARAMS") {
+ return result(
+ &[
+ "METHOD_NAME",
+ "METHOD_NO",
+ "PARAM_NAME",
+ "PARAM_NO",
+ "PARAM_MODE",
+ "PARAM_TYPE_OWNER",
+ "PARAM_TYPE_NAME",
+ ],
+ vec![],
+ );
+ }
+ if sql.contains("ALL_METHOD_RESULTS") {
+ return result(&["METHOD_NAME", "METHOD_NO", "RESULT_TYPE_OWNER", "RESULT_TYPE_NAME"], vec![]);
+ }
+ if sql.contains("ALL_TABLES") {
+ return result(
+ &[
+ "TABLE_NAME",
+ "TEMPORARY",
+ "NESTED",
+ "IOT_TYPE",
+ "CLUSTER_NAME",
+ "PARTITIONED",
+ "READ_ONLY",
+ "STATUS",
+ "TABLESPACE_NAME",
+ ],
+ vec![vec![
+ json!("DATA"),
+ json!("N"),
+ json!("NO"),
+ Value::Null,
+ if f.forbidden == Some("cluster") { json!("C") } else { Value::Null },
+ json!(if f.forbidden == Some("partition") { "YES" } else { "NO" }),
+ json!("NO"),
+ json!("VALID"),
+ json!("USERS"),
+ ]],
+ );
+ }
+ if sql.contains("ALL_EXTERNAL_TABLES") || sql.contains("ALL_OBJECT_TABLES") {
+ return result(&["TABLE_NAME"], vec![]);
+ }
+ if sql.contains("ALL_TAB_COLS") {
+ return result(
+ &[
+ "COLUMN_NAME",
+ "COLUMN_ID",
+ "DATA_TYPE_OWNER",
+ "DATA_TYPE",
+ "DATA_LENGTH",
+ "DATA_PRECISION",
+ "DATA_SCALE",
+ "CHAR_USED",
+ "CHAR_LENGTH",
+ "NULLABLE",
+ "HIDDEN_COLUMN",
+ "USER_GENERATED",
+ "VIRTUAL_COLUMN",
+ ],
+ vec![vec![
+ json!("VALUE"),
+ json!(1),
+ json!("APP"),
+ json!("ROOT"),
+ Value::Null,
+ Value::Null,
+ Value::Null,
+ Value::Null,
+ Value::Null,
+ json!("Y"),
+ json!("NO"),
+ json!("YES"),
+ json!("NO"),
+ ]],
+ );
+ }
+ if sql.contains("ALL_INDEXES") {
+ return result(
+ &["INDEX_NAME", "INDEX_TYPE", "STATUS"],
+ if f.forbidden == Some("index") {
+ vec![vec![json!("FX"), json!("FUNCTION-BASED NORMAL"), json!("VALID")]]
+ } else {
+ vec![]
+ },
+ );
+ }
+ if sql.contains("ALL_IND_COLUMNS") {
+ return result(&["INDEX_NAME", "COLUMN_NAME", "COLUMN_POSITION"], vec![]);
+ }
+ if sql.contains("ALL_VARRAYS") {
+ return result(
+ &["TYPE_OWNER", "TYPE_NAME", "LOB_NAME"],
+ if f.varray {
+ vec![vec![
+ json!("APP"),
+ json!("ROOT"),
+ if f.forbidden == Some("inline") { Value::Null } else { json!("LOB_DATA") },
+ ]]
+ } else {
+ vec![]
+ },
+ );
+ }
+ if sql.contains("ALL_LOBS") {
+ return result(
+ &["SEGMENT_NAME", "TABLESPACE_NAME", "COLUMN_NAME"],
+ if f.varray && f.forbidden != Some("missing-lob") {
+ vec![vec![json!("LOB_DATA"), json!("USERS"), json!("VALUE")]]
+ } else {
+ vec![]
+ },
+ );
+ }
+ if sql.contains("ALL_TAB_PRIVS") {
+ return result(&["TABLE_NAME", "GRANTEE", "GRANTOR", "PRIVILEGE", "GRANTABLE"], vec![]);
+ }
+ if sql.contains("USER_TABLESPACES") {
+ return result(
+ &["TABLESPACE_NAME", "STATUS"],
+ vec![vec![
+ json!("USERS"),
+ json!(if f.forbidden == Some("tablespace") { "READ ONLY" } else { "ONLINE" }),
+ ]],
+ );
+ }
+ if sql.contains("COUNT(*)") {
+ return result(&["ROW_COUNT"], vec![vec![json!(f.rows.to_string())]]);
+ }
+ Err(format!("Unscripted native metadata query: {sql}"))
+ }
+ async fn run(
+ f: Rc<RefCell<Fixture>>,
+ input: OracleTypeEvolutionRequest,
+ ) -> Result<OracleTypeEvolutionManifest, String> {
+ let mut snapshot = snapshot();
+ snapshot.objects[0].source = Some(input.source_before.clone());
+ read(input, snapshot, move |sql| std::future::ready(query(&f.borrow(), &sql))).await
+ }
+ #[tokio::test]
+ async fn native_varray_limit_requires_verified_existing_lob_storage_and_keeps_the_original_guards() {
+ let f = Rc::new(RefCell::new(Fixture { varray: true, rows: 3, ..Default::default() }));
+ let mut input = request(None);
+ input.source_before = "CREATE TYPE APP.ROOT AS VARRAY(10) OF NUMBER(8,0);".into();
+ input.source_after = "CREATE TYPE APP.ROOT AS VARRAY(30) OF NUMBER(8,0);".into();
+ let original = run(f.clone(), input.clone()).await.unwrap();
+ assert_eq!(original.statements.len(), 1);
+ input.manifest = Some(original.clone());
+ f.borrow_mut().phase = 1;
+ let observed = run(f.clone(), input.clone()).await.unwrap();
+ assert_eq!(observed.phase, 1);
+ assert_eq!(observed.metadata, original.metadata);
+ for reason in ["inline", "missing-lob"] {
+ f.borrow_mut().forbidden = Some(reason);
+ assert!(run(f.clone(), input.clone()).await.is_err(), "{reason}");
+ }
+ }
+ #[tokio::test]
+ async fn native_metadata_proves_each_phase_without_manual_baselines_or_udt_transport() {
+ let f = Rc::new(RefCell::new(Fixture { rows: 3, ..Default::default() }));
+ let original = run(f.clone(), request(None)).await.unwrap();
+ assert_eq!(original.phase, 0);
+ assert_eq!(original.statements.len(), 2);
+ for phase in [1, 2] {
+ f.borrow_mut().phase = phase;
+ let actual = run(f.clone(), request(Some(original.clone()))).await.unwrap();
+ assert_eq!(actual.phase, phase);
+ assert_eq!(actual.metadata, original.metadata);
+ }
+ }
+ #[tokio::test]
+ async fn native_metadata_rejects_restrictions_unknowns_and_changed_original_identity_or_counts() {
+ let f = Rc::new(RefCell::new(Fixture { rows: 3, ..Default::default() }));
+ let original = run(f.clone(), request(None)).await.unwrap();
+ for reason in ["version", "edition", "inheritance", "cluster", "partition", "index", "tablespace", "truncated"]
+ {
+ f.borrow_mut().forbidden = Some(reason);
+ assert!(run(f.clone(), request(Some(original.clone()))).await.is_err(), "{reason}");
+ }
+ f.borrow_mut().forbidden = None;
+ f.borrow_mut().table_id = "replaced-table";
+ assert!(run(f.clone(), request(Some(original.clone()))).await.is_err());
+ f.borrow_mut().table_id = "";
+ f.borrow_mut().rows = 4;
+ assert!(run(f.clone(), request(Some(original))).await.is_err());
+ }
+}
diff --git a/crates/dbx-core/src/schema/oracle_type_management.rs b/crates/dbx-core/src/schema/oracle_type_management.rs
new file mode 100644
index 0000000000..50c8e73d9b
--- /dev/null
+++ b/crates/dbx-core/src/schema/oracle_type_management.rs
@@ -0,0 +1,1220 @@
+//! Read-only inputs for the controlled Oracle-family TYPE manager.
+//!
+//! These readers deliberately preserve partial rows and report the completeness
+//! of each dictionary independently. An empty vector is never a substitute for
+//! a failed, truncated, or structurally incomplete read.
+
+use super::sql_string;
+use crate::db;
+use crate::db::{
+ OracleTypeManagementDependency, OracleTypeManagementError, OracleTypeManagementObject,
+ OracleTypeManagementPrivilege, OracleTypeManagementReference, TypeMetadataRead, TypeMetadataState,
+};
+use serde_json::Value;
+use std::collections::{HashSet, VecDeque};
+use std::future::Future;
+
+const MAX_DEPENDENCY_OBJECTS: usize = 500;
+
+/// QueryResult deliberately omits result-grid preview metadata. TYPE readers
+/// must consume it before that shared model can discard a deferred cell flag.
+#[derive(serde::Deserialize)]
+#[serde(try_from = "Value")]
+pub(super) struct QueryResponse {
+ result: db::QueryResult,
+ metadata: QueryResponseMetadata,
+}
+
+#[derive(serde::Deserialize)]
+struct QueryResponseMetadata {
+ #[serde(default, alias = "largeValueCells")]
+ large_value_cells: Option<Vec<Value>>,
+ #[serde(default, alias = "executionError")]
+ execution_error: bool,
+ #[serde(default, alias = "hasMore")]
+ has_more: bool,
+}
+
+impl TryFrom<Value> for QueryResponse {
+ type Error = serde_json::Error;
+
+ fn try_from(value: Value) -> Result<Self, Self::Error> {
+ // serde's flatten buffer cannot deserialize QueryResult's u128 timing.
+ // Read the flags by reference, then decode the ordinary result unchanged.
+ let metadata = <QueryResponseMetadata as serde::Deserialize>::deserialize(&value)?;
+ Ok(Self { result: serde_json::from_value(value)?, metadata })
+ }
+}
+
+impl QueryResponse {
+ pub(super) fn into_result(self) -> Result<db::QueryResult, String> {
+ if self.metadata.execution_error {
+ return Err(
+ "The TYPE query returned an execution error; no complete metadata or scalar values were accepted"
+ .into(),
+ );
+ }
+ let mut result = self.result;
+ result.has_more |= self.metadata.has_more;
+ result.truncated |= self.metadata.large_value_cells.is_some_and(|cells| !cells.is_empty());
+ Ok(result)
+ }
+}
+
+pub(super) fn available() -> TypeMetadataRead {
+ TypeMetadataRead { state: TypeMetadataState::Available, reason: None }
+}
+
+pub(super) fn unavailable(reason: impl Into<String>) -> TypeMetadataRead {
+ TypeMetadataRead { state: TypeMetadataState::Unavailable, reason: Some(reason.into()) }
+}
+
+fn incomplete(read: &mut TypeMetadataRead, reason: impl Into<String>) {
+ if matches!(read.state, TypeMetadataState::Unavailable | TypeMetadataState::Unsupported) {
+ return;
+ }
+ read.state = TypeMetadataState::Incomplete;
+ let reason = reason.into();
+ read.reason = Some(match read.reason.take() {
+ Some(previous) => format!("{previous}; {reason}"),
+ None => reason,
+ });
+}
+
+pub(super) struct Rows {
+ pub(super) columns: Vec<String>,
+ pub(super) rows: Vec<Vec<Value>>,
+ pub(super) read: TypeMetadataRead,
+}
+
+impl Rows {
+ pub(super) fn new(result: Result<db::QueryResult, String>, required: &[&str]) -> Self {
+ match result {
+ Err(error) => Self { columns: Vec::new(), rows: Vec::new(), read: unavailable(error) },
+ Ok(result) => {
+ let mut read = available();
+ if result.truncated || result.has_more {
+ incomplete(&mut read, "Dictionary result was truncated or has more rows");
+ }
+ if result.messages.iter().any(|message| message.severity.eq_ignore_ascii_case("ERROR")) {
+ incomplete(&mut read, "Dictionary query returned an execution error message");
+ }
+ if result.rows.iter().any(|row| {
+ row.len() != result.columns.len() || row.iter().any(|cell| cell.is_array() || cell.is_object())
+ }) {
+ incomplete(&mut read, "Dictionary cells are incomplete or contain unresolved large-value data");
+ }
+ let missing: Vec<_> = required
+ .iter()
+ .filter(|column| !result.columns.iter().any(|actual| actual.eq_ignore_ascii_case(column)))
+ .copied()
+ .collect();
+ if !missing.is_empty() {
+ incomplete(&mut read, format!("Missing dictionary columns: {}", missing.join(", ")));
+ }
+ Self { columns: result.columns, rows: result.rows, read }
+ }
+ }
+ }
+
+ pub(super) fn value<'a>(&self, row: &'a [Value], column: &str) -> Option<&'a Value> {
+ self.columns
+ .iter()
+ .position(|actual| actual.eq_ignore_ascii_case(column))
+ .and_then(|index| row.get(index))
+ .filter(|value| !value.is_null())
+ }
+
+ pub(super) fn text(&self, row: &[Value], column: &str) -> Option<String> {
+ self.value(row, column).and_then(|value| match value {
+ Value::String(text) if !text.is_empty() => Some(text.clone()),
+ Value::Number(number) => Some(number.to_string()),
+ _ => None,
+ })
+ }
+
+ pub(super) fn yes_no(&self, row: &[Value], column: &str) -> Option<bool> {
+ match self.text(row, column)?.to_ascii_uppercase().as_str() {
+ "YES" | "Y" | "TRUE" => Some(true),
+ "NO" | "N" | "FALSE" => Some(false),
+ _ => None,
+ }
+ }
+}
+
+pub(super) async fn acting_user<F, Fut>(mut run: F) -> (Option<String>, TypeMetadataRead)
+where
+ F: FnMut(String) -> Fut,
+ Fut: Future<Output = Result<db::QueryResult, String>>,
+{
+ let rows = Rows::new(run("SELECT USER AS ACTING_USER FROM DUAL".into()).await, &["ACTING_USER"]);
+ let mut read = rows.read.clone();
+ let user = if rows.rows.len() == 1 { rows.text(&rows.rows[0], "ACTING_USER") } else { None };
+ if user.is_none() {
+ incomplete(&mut read, "The active grantor identity could not be verified");
+ }
+ (user, read)
+}
+
+/// State, identity and diagnostics remain separate: INVALID with no errors is
+/// still INVALID, and an empty successful catalogue is distinct from a failed read.
+pub(super) async fn object_metadata<F, Fut>(
+ dialect: super::oracle_type_details::Dialect,
+ owner: &str,
+ name: &str,
+ object_type: &str,
+ mut run: F,
+) -> OracleTypeManagementObject
+where
+ F: FnMut(String) -> Fut,
+ Fut: Future<Output = Result<db::QueryResult, String>>,
+{
+ let query = if dialect == super::oracle_type_details::Dialect::Dameng && !object_type.ends_with(" BODY") {
+ let subtypes = match object_type {
+ "TYPE" => "('TYPE','CLASS','CLLT')",
+ "PROCEDURE" | "FUNCTION" => "('PROC')",
+ "PACKAGE" => "('PKG')",
+ "VIEW" | "MATERIALIZED VIEW" => "('VIEW')",
+ "TABLE" => "('UTAB')",
+ "TRIGGER" => "('TRIG')",
+ "SYNONYM" => "('SYNOM')",
+ _ => "('')",
+ };
+ format!(
+ "SELECT O.ID AS OBJECT_ID, O.VALID AS STATUS FROM SYSOBJECTS O JOIN SYSOBJECTS S ON S.ID=O.SCHID AND S.TYPE$='SCH' WHERE S.NAME={} AND O.NAME={} AND O.TYPE$='SCHOBJ' AND O.SUBTYPE$ IN {subtypes}",
+ sql_string(owner), sql_string(name),
+ )
+ } else {
+ format!(
+ "SELECT OBJECT_ID, STATUS FROM ALL_OBJECTS WHERE OWNER={} AND OBJECT_NAME={} AND OBJECT_TYPE={}",
+ sql_string(owner),
+ sql_string(name),
+ sql_string(object_type),
+ )
+ };
+ let rows = Rows::new(run(query).await, &["OBJECT_ID", "STATUS"]);
+ let mut status_read = rows.read.clone();
+ let mut exists = None;
+ let mut object_id = None;
+ let mut status = None;
+ if status_read.state == TypeMetadataState::Available {
+ match rows.rows.as_slice() {
+ [] => exists = Some(false),
+ [row] => {
+ exists = Some(true);
+ object_id = rows.text(row, "OBJECT_ID");
+ status = rows.text(row, "STATUS").and_then(|value| match value.to_ascii_uppercase().as_str() {
+ "Y" | "VALID" => Some("VALID".into()),
+ "N" | "INVALID" => Some("INVALID".into()),
+ _ => None,
+ });
+ if object_id.is_none() || status.is_none() {
+ incomplete(&mut status_read, "Object identity or compilation state is unknown");
+ }
+ }
+ _ => incomplete(&mut status_read, "Object identity is ambiguous"),
+ }
+ }
+ let (errors, errors_read) = if exists == Some(true) && object_type != "TABLE" {
+ compilation_errors(dialect, owner, name, object_type, &mut run).await
+ } else if exists == Some(false) {
+ (Vec::new(), available())
+ } else {
+ (Vec::new(), unavailable("Compilation diagnostics are not available for this object state"))
+ };
+ let (trigger_enabled, trigger_enabled_read) = if object_type == "TRIGGER" && exists == Some(true) {
+ let rows = Rows::new(
+ run(format!(
+ "SELECT STATUS FROM ALL_TRIGGERS WHERE OWNER={} AND TRIGGER_NAME={}",
+ sql_string(owner),
+ sql_string(name)
+ ))
+ .await,
+ &["STATUS"],
+ );
+ let mut read = rows.read.clone();
+ let enabled = if rows.rows.len() == 1 {
+ match rows.text(&rows.rows[0], "STATUS").as_deref() {
+ Some("ENABLED") => Some(true),
+ Some("DISABLED") => Some(false),
+ Some("Y") if dialect == super::oracle_type_details::Dialect::Dameng => Some(true),
+ Some("N") if dialect == super::oracle_type_details::Dialect::Dameng => Some(false),
+ _ => None,
+ }
+ } else {
+ None
+ };
+ if enabled.is_none() {
+ incomplete(&mut read, "The exact trigger ENABLED/DISABLED state is unknown");
+ }
+ (enabled, Some(read))
+ } else {
+ (None, None)
+ };
+ OracleTypeManagementObject {
+ owner: owner.into(),
+ name: name.into(),
+ object_type: object_type.into(),
+ exists,
+ object_id,
+ status,
+ status_read,
+ trigger_enabled,
+ trigger_enabled_read,
+ source: None,
+ source_read: unavailable("Source has not been read"),
+ source_fingerprint: None,
+ errors,
+ errors_read,
+ direct_privileges: Vec::new(),
+ privileges_read: unavailable("Direct grants have not been read"),
+ }
+}
+
+pub(super) async fn compilation_errors<F, Fut>(
+ dialect: super::oracle_type_details::Dialect,
+ owner: &str,
+ name: &str,
+ object_type: &str,
+ mut run: F,
+) -> (Vec<OracleTypeManagementError>, TypeMetadataRead)
+where
+ F: FnMut(String) -> Fut,
+ Fut: Future<Output = Result<db::QueryResult, String>>,
+{
+ let typed = dialect == super::oracle_type_details::Dialect::Oracle;
+ let attribute = if typed { ", ATTRIBUTE" } else { "" };
+ let required =
+ if typed { &["LINE", "POSITION", "TEXT", "ATTRIBUTE"][..] } else { &["LINE", "POSITION", "TEXT"][..] };
+ let rows = Rows::new(
+ run(format!(
+ "SELECT LINE, POSITION, TEXT{attribute} FROM ALL_ERRORS WHERE OWNER={} AND NAME={} AND TYPE={} ORDER BY SEQUENCE",
+ sql_string(owner),
+ sql_string(name),
+ sql_string(object_type),
+ ))
+ .await,
+ required,
+ );
+ let mut read = rows.read.clone();
+ let mut errors = Vec::new();
+ let mut warnings = Vec::new();
+ for row in &rows.rows {
+ match (
+ rows.text(row, "LINE").and_then(|value| value.parse::<u32>().ok()),
+ rows.text(row, "POSITION").and_then(|value| value.parse::<u32>().ok()),
+ rows.text(row, "TEXT"),
+ ) {
+ (Some(line), Some(position), Some(text)) => {
+ match if typed { rows.text(row, "ATTRIBUTE") } else { Some("ERROR".into()) }.as_deref() {
+ Some("ERROR") => errors.push(OracleTypeManagementError { line, position, text }),
+ Some("WARNING") => warnings.push(format!("{line}:{position} {text}")),
+ _ => incomplete(&mut read, "The compilation diagnostic severity is unknown"),
+ }
+ }
+ _ => incomplete(&mut read, "A compilation diagnostic has an unreadable position or message"),
+ }
+ }
+ if !warnings.is_empty() {
+ let warning = format!("Compilation warnings:\n{}", warnings.join("\n"));
+ read.reason = Some(match read.reason.take() {
+ Some(reason) => format!("{reason}; {warning}"),
+ None => warning,
+ });
+ }
+ (errors, read)
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+struct ObjectKey {
+ owner: String,
+ name: String,
+ object_type: String,
+}
+
+fn dependency_query(key: &ObjectKey) -> String {
+ format!(
+ "SELECT OWNER, NAME, TYPE, REFERENCED_OWNER, REFERENCED_NAME, REFERENCED_TYPE, REFERENCED_LINK_NAME FROM ALL_DEPENDENCIES WHERE REFERENCED_OWNER = {} AND REFERENCED_NAME = {} AND REFERENCED_TYPE = {}",
+ sql_string(&key.owner),
+ sql_string(&key.name),
+ sql_string(&key.object_type),
+ )
+}
+
+fn dameng_dependency_query(key: &ObjectKey) -> String {
+ let object_types = match key.object_type.as_str() {
+ "TYPE" => "('TYPE','CLASS')".to_string(),
+ other => format!("({})", sql_string(other)),
+ };
+ format!(
+ "SELECT DS.NAME AS OWNER, DOBJ.NAME AS NAME, D.TYPE$ AS TYPE, RS.NAME AS REFERENCED_OWNER, ROBJ.NAME AS REFERENCED_NAME, D.REFED_TYPE$ AS REFERENCED_TYPE, CAST(NULL AS VARCHAR(128)) AS REFERENCED_LINK_NAME FROM SYSDEPENDENCIES D LEFT JOIN SYSOBJECTS DOBJ ON DOBJ.ID = D.ID JOIN SYSOBJECTS ROBJ ON ROBJ.ID = D.REFED_ID LEFT JOIN SYSOBJECTS DS ON DS.ID = DOBJ.SCHID AND DS.TYPE$ = 'SCH' LEFT JOIN SYSOBJECTS RS ON RS.ID = ROBJ.SCHID AND RS.TYPE$ = 'SCH' WHERE RS.NAME = {} AND ROBJ.NAME = {} AND D.REFED_TYPE$ IN {object_types}",
+ sql_string(&key.owner),
+ sql_string(&key.name),
+ )
+}
+
+fn canonical_object_type(value: &str) -> String {
+ match value.to_ascii_uppercase().as_str() {
+ "CLASS" | "CLLT" => "TYPE".into(),
+ "CLASS_BODY" | "TYPE_BODY" => "TYPE BODY".into(),
+ "PACKAGE_BODY" => "PACKAGE BODY".into(),
+ other => other.into(),
+ }
+}
+
+pub(super) async fn dependencies<F, Fut>(
+ dialect: super::oracle_type_details::Dialect,
+ owner: &str,
+ name: &str,
+ mut run: F,
+) -> (Vec<OracleTypeManagementDependency>, TypeMetadataRead)
+where
+ F: FnMut(String) -> Fut,
+ Fut: Future<Output = Result<db::QueryResult, String>>,
+{
+ let mut output = Vec::new();
+ let mut read = available();
+ let mut pending = VecDeque::from([
+ ObjectKey { owner: owner.to_string(), name: name.to_string(), object_type: "TYPE".to_string() },
+ ObjectKey { owner: owner.to_string(), name: name.to_string(), object_type: "TYPE BODY".to_string() },
+ ]);
+ let mut queried = HashSet::new();
+ let mut seen = HashSet::<(String, String, String, String, String, String, Option<String>)>::new();
+ while let Some(key) = pending.pop_front() {
+ if !queried.insert(key.clone()) {
+ continue;
+ }
+ // DM explicitly excludes body kinds from REFED_TYPE$; their outgoing
+ // edges are still returned when the corresponding specification is read.
+ if dialect == super::oracle_type_details::Dialect::Dameng && key.object_type.ends_with(" BODY") {
+ continue;
+ }
+ let query = if dialect == super::oracle_type_details::Dialect::Dameng {
+ dameng_dependency_query(&key)
+ } else {
+ dependency_query(&key)
+ };
+ let rows = Rows::new(
+ run(query).await,
+ &[
+ "OWNER",
+ "NAME",
+ "TYPE",
+ "REFERENCED_OWNER",
+ "REFERENCED_NAME",
+ "REFERENCED_TYPE",
+ "REFERENCED_LINK_NAME",
+ ],
+ );
+ if rows.read.state != TypeMetadataState::Available {
+ incomplete(&mut read, rows.read.reason.clone().unwrap_or_else(|| "Dependency read is incomplete".into()));
+ }
+ for row in &rows.rows {
+ let Some(dep_owner) = rows.text(row, "OWNER") else {
+ incomplete(&mut read, "A dependency owner is missing");
+ continue;
+ };
+ let Some(dep_name) = rows.text(row, "NAME") else {
+ incomplete(&mut read, "A dependency name is missing");
+ continue;
+ };
+ let Some(dep_type) = rows.text(row, "TYPE").map(|value| canonical_object_type(&value)) else {
+ incomplete(&mut read, "A dependency object type is missing");
+ continue;
+ };
+ let Some(referenced_owner) = rows.text(row, "REFERENCED_OWNER") else {
+ incomplete(&mut read, "A referenced owner is missing");
+ continue;
+ };
+ let Some(referenced_name) = rows.text(row, "REFERENCED_NAME") else {
+ incomplete(&mut read, "A referenced name is missing");
+ continue;
+ };
+ let Some(referenced_type) = rows.text(row, "REFERENCED_TYPE").map(|value| canonical_object_type(&value))
+ else {
+ incomplete(&mut read, "A referenced object type is missing");
+ continue;
+ };
+ let referenced_link = rows.text(row, "REFERENCED_LINK_NAME");
+ let dependency = OracleTypeManagementDependency {
+ owner: dep_owner.clone(),
+ name: dep_name.clone(),
+ object_type: dep_type.clone(),
+ referenced_owner,
+ referenced_name,
+ referenced_type,
+ referenced_link: referenced_link.clone(),
+ };
+ if seen.insert((
+ dependency.owner.clone(),
+ dependency.name.clone(),
+ dependency.object_type.clone(),
+ dependency.referenced_owner.clone(),
+ dependency.referenced_name.clone(),
+ dependency.referenced_type.clone(),
+ dependency.referenced_link.clone(),
+ )) {
+ output.push(dependency);
+ }
+ if referenced_link.is_some() {
+ incomplete(&mut read, "A dependency crosses a database link and cannot be traversed");
+ } else if queried.len() + pending.len() < MAX_DEPENDENCY_OBJECTS {
+ pending.push_back(ObjectKey { owner: dep_owner, name: dep_name, object_type: dep_type });
+ } else {
+ incomplete(&mut read, "Dependency closure exceeded the 500-object read limit");
+ }
+ }
+ }
+ (output, read)
+}
+
+pub(super) async fn persistent_references<F, Fut>(
+ dialect: super::oracle_type_details::Dialect,
+ owner: &str,
+ name: &str,
+ mut run: F,
+) -> (Vec<OracleTypeManagementReference>, TypeMetadataRead)
+where
+ F: FnMut(String) -> Fut,
+ Fut: Future<Output = Result<db::QueryResult, String>>,
+{
+ let result = if dialect == super::oracle_type_details::Dialect::Dameng {
+ run(format!(
+ "SELECT DISTINCT S.NAME AS OWNER, O.NAME AS TABLE_NAME, CAST(NULL AS VARCHAR(128)) AS COLUMN_NAME, {} AS DATA_TYPE_OWNER, {} AS DATA_TYPE, CAST(NULL AS VARCHAR(5)) AS READ_ONLY FROM SYSDEPENDENCIES D JOIN SYSOBJECTS O ON O.ID = D.ID AND O.TYPE$ = 'SCHOBJ' AND O.SUBTYPE$ = 'UTAB' JOIN SYSOBJECTS S ON S.ID = O.SCHID AND S.TYPE$ = 'SCH' WHERE D.REFED_ID IN (SELECT T.ID FROM SYSOBJECTS T JOIN SYSOBJECTS TS ON TS.ID = T.SCHID AND TS.TYPE$ = 'SCH' WHERE TS.NAME = {} AND T.NAME = {} AND T.TYPE$ = 'SCHOBJ' AND T.SUBTYPE$ IN ('TYPE', 'CLASS', 'CLLT')) AND D.REFED_TYPE$ IN ('TYPE','CLASS')",
+ sql_string(owner), sql_string(name), sql_string(owner), sql_string(name)
+ )).await
+ } else {
+ run(format!(
+ "SELECT C.OWNER, C.TABLE_NAME, C.COLUMN_NAME, C.DATA_TYPE_OWNER, C.DATA_TYPE, T.READ_ONLY FROM ALL_TAB_COLUMNS C LEFT JOIN ALL_TABLES T ON T.OWNER = C.OWNER AND T.TABLE_NAME = C.TABLE_NAME WHERE C.DATA_TYPE_OWNER = {} AND C.DATA_TYPE = {}",
+ sql_string(owner),
+ sql_string(name),
+ )).await
+ };
+ let rows = Rows::new(result, &["OWNER", "TABLE_NAME", "COLUMN_NAME", "DATA_TYPE_OWNER", "DATA_TYPE", "READ_ONLY"]);
+ let mut read = rows.read.clone();
+ let mut references = Vec::new();
+ for row in &rows.rows {
+ let (Some(owner), Some(table_name)) = (rows.text(row, "OWNER"), rows.text(row, "TABLE_NAME")) else {
+ incomplete(&mut read, "A persistent type reference has incomplete identity");
+ continue;
+ };
+ let column_name = rows.text(row, "COLUMN_NAME");
+ if column_name.is_none() {
+ incomplete(&mut read, format!("The exact persistent column must be verified for {owner}.{table_name}"));
+ }
+ let table_read_only = rows.yes_no(row, "READ_ONLY");
+ if table_read_only.is_none() {
+ incomplete(&mut read, format!("Read-only state is unknown for {owner}.{table_name}"));
+ }
+ references.push(OracleTypeManagementReference {
+ owner,
+ table_name,
+ column_name,
+ data_type_owner: rows.text(row, "DATA_TYPE_OWNER"),
+ data_type: rows.text(row, "DATA_TYPE"),
+ table_status: None,
+ table_read_only,
+ });
+ }
+ (references, read)
+}
+
+pub(super) async fn direct_privileges<F, Fut>(
+ dialect: super::oracle_type_details::Dialect,
+ owner: &str,
+ name: &str,
+ mut run: F,
+) -> (Vec<OracleTypeManagementPrivilege>, TypeMetadataRead)
+where
+ F: FnMut(String) -> Fut,
+ Fut: Future<Output = Result<db::QueryResult, String>>,
+{
+ let (result, required) = if dialect == super::oracle_type_details::Dialect::Dameng {
+ (
+ run(format!(
+ "SELECT G.URID, G.OBJID, G.COLID, G.PRIVID, G.GRANTOR, G.GRANTABLE, U.NAME AS GRANTEE, GU.NAME AS GRANTOR_NAME, A.NAME AS PRIVILEGE, A.TYPE AS PRIVILEGE_TYPE FROM SYSOBJECTS O JOIN SYSOBJECTS S ON S.ID = O.SCHID AND S.TYPE$ = 'SCH' JOIN SYSGRANTS G ON G.OBJID = O.ID LEFT JOIN SYSOBJECTS U ON U.ID = G.URID AND U.TYPE$ = 'UR' LEFT JOIN SYSOBJECTS GU ON GU.ID = G.GRANTOR AND GU.TYPE$ = 'UR' LEFT JOIN V$AUTHORITIES A ON A.ID = G.PRIVID WHERE S.NAME = {} AND O.NAME = {} AND O.TYPE$ = 'SCHOBJ' AND O.SUBTYPE$ IN ('CLASS', 'TYPE', 'CLLT')",
+ sql_string(owner),
+ sql_string(name),
+ ))
+ .await,
+ &["URID", "OBJID", "COLID", "PRIVID", "GRANTOR", "GRANTOR_NAME", "GRANTABLE", "GRANTEE", "PRIVILEGE", "PRIVILEGE_TYPE"][..],
+ )
+ } else {
+ (
+ run(format!(
+ "SELECT GRANTOR, GRANTEE, PRIVILEGE, GRANTABLE, HIERARCHY FROM ALL_TAB_PRIVS WHERE TABLE_SCHEMA = {} AND TABLE_NAME = {}",
+ sql_string(owner),
+ sql_string(name),
+ ))
+ .await,
+ &["GRANTOR", "GRANTEE", "PRIVILEGE", "GRANTABLE", "HIERARCHY"][..],
+ )
+ };
+ let rows = Rows::new(result, required);
+ let mut privileges = Vec::new();
+ let mut read = rows.read.clone();
+ for row in &rows.rows {
+ let grantee = rows.text(row, "GRANTEE").or_else(|| rows.text(row, "URID").map(|id| format!("ID:{id}")));
+ let privilege = rows.text(row, "PRIVILEGE").or_else(|| rows.text(row, "PRIVID").map(|id| format!("ID:{id}")));
+ match (grantee, privilege) {
+ (Some(grantee), Some(privilege)) => {
+ let grantor = if dialect == super::oracle_type_details::Dialect::Dameng {
+ let name = rows.text(row, "GRANTOR_NAME");
+ if name.is_none() {
+ incomplete(&mut read, "A DM grantor identifier could not be resolved to its name");
+ }
+ name.or_else(|| rows.text(row, "GRANTOR"))
+ } else {
+ rows.text(row, "GRANTOR")
+ };
+ if rows.value(row, "PRIVILEGE").is_none() || rows.value(row, "GRANTEE").is_none() {
+ incomplete(&mut read, "A direct privilege identifier could not be resolved to its name");
+ }
+ if dialect == super::oracle_type_details::Dialect::Dameng && rows.value(row, "PRIVILEGE_TYPE").is_none()
+ {
+ incomplete(&mut read, "A DM privilege type could not be resolved");
+ }
+ if dialect == super::oracle_type_details::Dialect::Dameng
+ && rows.text(row, "PRIVILEGE_TYPE").as_deref().is_some_and(|kind| kind != "2")
+ {
+ incomplete(&mut read, "A DM grant row is not a recognized object privilege");
+ }
+ privileges.push(OracleTypeManagementPrivilege {
+ grantee,
+ privilege,
+ grantable: rows.yes_no(row, "GRANTABLE"),
+ hierarchy: if dialect == super::oracle_type_details::Dialect::Dameng {
+ Some(false)
+ } else {
+ rows.yes_no(row, "HIERARCHY")
+ },
+ grantor,
+ privilege_id: rows.text(row, "PRIVID"),
+ privilege_type: rows.text(row, "PRIVILEGE_TYPE"),
+ column_id: rows.text(row, "COLID"),
+ });
+ }
+ _ => incomplete(&mut read, "A direct privilege row has incomplete identity"),
+ }
+ }
+ (privileges, read)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ #[test]
+ fn transport_large_cell_flags_cannot_be_discarded_before_completeness_checks() {
+ for key in ["large_value_cells", "largeValueCells"] {
+ let mut payload = json!({"columns":["TEXT"],"rows":[["preview"]],"affected_rows":0,"execution_time_ms":0});
+ payload[key] = json!([{"row_index":0,"column_index":0,"original_bytes":4096}]);
+ let response: QueryResponse = serde_json::from_value(payload).unwrap();
+ let rows = Rows::new(response.into_result(), &["TEXT"]);
+ assert_eq!(rows.read.state, TypeMetadataState::Incomplete);
+ assert_eq!(rows.rows[0][0], "preview");
+ }
+ }
+ #[test]
+ fn transport_more_rows_flags_remain_incomplete_in_both_wire_spellings() {
+ for key in ["has_more", "hasMore"] {
+ let mut payload = json!({"columns":["VALUE"],"rows":[["1"]],"affected_rows":0,"execution_time_ms":0});
+ payload[key] = json!(true);
+ let response: QueryResponse = serde_json::from_value(payload).unwrap();
+ assert_eq!(Rows::new(response.into_result(), &["VALUE"]).read.state, TypeMetadataState::Incomplete);
+ }
+ }
+ #[test]
+ fn transport_execution_errors_cannot_become_an_empty_successful_relation() {
+ for key in ["execution_error", "executionError"] {
+ let mut payload = json!({"columns":["VALUE"],"rows":[],"affected_rows":0,"execution_time_ms":0});
+ payload[key] = json!(true);
+ let response: QueryResponse = serde_json::from_value(payload).unwrap();
+ assert!(response.into_result().is_err());
+ }
+ }
+ use serde_json::json;
+ use std::collections::HashMap;
+
+ fn result(columns: &[&str], rows: Vec<Vec<Value>>) -> db::QueryResult {
+ serde_json::from_value(json!({"columns": columns, "rows": rows, "affected_rows": 0, "execution_time_ms": 0}))
+ .unwrap()
+ }
+
+ #[tokio::test]
+ async fn dependency_walk_is_recursive_exact_and_preserves_db_links_and_partial_rows() {
+ let mut scripted = HashMap::<String, Result<db::QueryResult, String>>::new();
+ let root = ObjectKey { owner: "APP".into(), name: "ROOT".into(), object_type: "TYPE".into() };
+ let coll = ObjectKey { owner: "APP".into(), name: "COLL".into(), object_type: "TYPE".into() };
+ scripted.insert(
+ dependency_query(&root),
+ Ok(result(
+ &[
+ "OWNER",
+ "NAME",
+ "TYPE",
+ "REFERENCED_OWNER",
+ "REFERENCED_NAME",
+ "REFERENCED_TYPE",
+ "REFERENCED_LINK_NAME",
+ ],
+ vec![vec![
+ json!("APP"),
+ json!("COLL"),
+ json!("TYPE"),
+ json!("APP"),
+ json!("ROOT"),
+ json!("TYPE"),
+ Value::Null,
+ ]],
+ )),
+ );
+ scripted.insert(
+ dependency_query(&coll),
+ Ok(result(
+ &[
+ "OWNER",
+ "NAME",
+ "TYPE",
+ "REFERENCED_OWNER",
+ "REFERENCED_NAME",
+ "REFERENCED_TYPE",
+ "REFERENCED_LINK_NAME",
+ ],
+ vec![
+ vec![
+ json!("APP"),
+ json!("DEEP"),
+ json!("TYPE"),
+ json!("APP"),
+ json!("COLL"),
+ json!("TYPE"),
+ Value::Null,
+ ],
+ vec![
+ json!("REMOTE"),
+ json!("PROC"),
+ json!("PROCEDURE"),
+ json!("APP"),
+ json!("COLL"),
+ json!("TYPE"),
+ json!("REMOTE_DB"),
+ ],
+ ],
+ )),
+ );
+ let (dependencies, read) =
+ dependencies(super::super::oracle_type_details::Dialect::Oracle, "APP", "ROOT", |sql| {
+ std::future::ready(scripted.remove(&sql).unwrap_or_else(|| {
+ Ok(result(
+ &[
+ "OWNER",
+ "NAME",
+ "TYPE",
+ "REFERENCED_OWNER",
+ "REFERENCED_NAME",
+ "REFERENCED_TYPE",
+ "REFERENCED_LINK_NAME",
+ ],
+ vec![],
+ ))
+ }))
+ })
+ .await;
+ assert_eq!(dependencies.len(), 3);
+ assert_eq!(read.state, TypeMetadataState::Incomplete);
+ assert!(read.reason.unwrap().contains("database link"));
+ assert!(dependencies.iter().any(|dependency| dependency.name == "DEEP"));
+ assert!(dependencies.iter().any(|dependency| dependency.referenced_link.as_deref() == Some("REMOTE_DB")));
+ }
+
+ #[tokio::test]
+ async fn dameng_dependency_walk_uses_documented_object_ids_and_schema_ids() {
+ let mut queries = Vec::new();
+ let (dependencies, read) =
+ dependencies(super::super::oracle_type_details::Dialect::Dameng, "APP", "ROOT", |sql| {
+ queries.push(sql);
+ std::future::ready(Ok(result(
+ &[
+ "OWNER",
+ "NAME",
+ "TYPE",
+ "REFERENCED_OWNER",
+ "REFERENCED_NAME",
+ "REFERENCED_TYPE",
+ "REFERENCED_LINK_NAME",
+ ],
+ vec![vec![
+ json!("APP"),
+ json!("COLL"),
+ json!("TYPE"),
+ json!("APP"),
+ json!("ROOT"),
+ json!("TYPE"),
+ Value::Null,
+ ]],
+ )))
+ })
+ .await;
+ assert_eq!(dependencies.len(), 1);
+ assert_eq!(read.state, TypeMetadataState::Available);
+ assert_eq!(queries.len(), 2, "DM has no body reference kind; root and discovered dependent TYPE are walked");
+ assert!(queries.iter().all(|sql| sql.contains("FROM SYSDEPENDENCIES D")));
+ assert!(queries.iter().all(|sql| sql.contains("DOBJ.SCHID") && sql.contains("RS.ID = ROBJ.SCHID")));
+ assert!(queries.iter().all(|sql| !sql.contains("ALL_DEPENDENCIES")));
+ }
+
+ #[tokio::test]
+ async fn persisted_reference_unknown_read_only_state_is_not_treated_as_writable() {
+ let (references, read) =
+ persistent_references(super::super::oracle_type_details::Dialect::Oracle, "APP", "ROOT", |_| {
+ std::future::ready(Ok(result(
+ &["OWNER", "TABLE_NAME", "COLUMN_NAME", "DATA_TYPE_OWNER", "DATA_TYPE", "READ_ONLY"],
+ vec![vec![json!("APP"), json!("DATA"), json!("VALUE"), json!("APP"), json!("ROOT"), Value::Null]],
+ )))
+ })
+ .await;
+ assert_eq!(references.len(), 1);
+ assert_eq!(references[0].table_read_only, None);
+ assert_eq!(read.state, TypeMetadataState::Incomplete);
+ }
+
+ #[tokio::test]
+ async fn dameng_persistent_references_use_dependency_ids_and_keep_read_only_unknown() {
+ let (references, read) =
+ persistent_references(super::super::oracle_type_details::Dialect::Dameng, "APP", "ROOT", |sql| {
+ assert!(sql.contains("FROM SYSDEPENDENCIES D"));
+ assert!(sql.contains("D.REFED_ID IN (SELECT T.ID"));
+ assert!(
+ !sql.contains("C.TYPE$ ="),
+ "An unverified type-name encoding must not hide table dependencies"
+ );
+ assert!(!sql.contains("ALL_TAB_COLUMNS"));
+ std::future::ready(Ok(result(
+ &["OWNER", "TABLE_NAME", "COLUMN_NAME", "DATA_TYPE_OWNER", "DATA_TYPE", "READ_ONLY"],
+ vec![vec![json!("APP"), json!("DATA"), Value::Null, json!("APP"), json!("ROOT"), Value::Null]],
+ )))
+ })
+ .await;
+ assert_eq!(references.len(), 1);
+ assert_eq!(references[0].column_name, None);
+ assert_eq!(references[0].table_read_only, None);
+ assert_eq!(read.state, TypeMetadataState::Incomplete);
+ }
+
+ #[tokio::test]
+ async fn direct_privileges_use_table_schema_and_failures_do_not_become_empty_available() {
+ let (privileges, read) =
+ direct_privileges(super::super::oracle_type_details::Dialect::OceanBase, "APP", "ROOT", |sql| {
+ assert!(sql.contains("TABLE_SCHEMA = 'APP'"));
+ assert!(!sql.contains("OWNER ="));
+ std::future::ready(Err("insufficient privilege".into()))
+ })
+ .await;
+ assert!(privileges.is_empty());
+ assert_eq!(read.state, TypeMetadataState::Unavailable);
+ }
+
+ #[tokio::test]
+ async fn dameng_grants_preserve_unresolved_authority_rows_as_incomplete() {
+ let (privileges, read) =
+ direct_privileges(super::super::oracle_type_details::Dialect::Dameng, "APP", "ROOT", |sql| {
+ assert!(sql.contains("JOIN SYSGRANTS G ON G.OBJID = O.ID"));
+ assert!(sql.contains("LEFT JOIN V$AUTHORITIES A ON A.ID = G.PRIVID"));
+ assert!(sql.contains("G.GRANTABLE"));
+ assert!(!sql.contains("HIERARCHY"));
+ std::future::ready(Ok(result(
+ &[
+ "URID",
+ "OBJID",
+ "COLID",
+ "PRIVID",
+ "GRANTOR",
+ "GRANTABLE",
+ "GRANTEE",
+ "PRIVILEGE",
+ "PRIVILEGE_TYPE",
+ ],
+ vec![vec![
+ json!(7),
+ json!(11),
+ json!(-1),
+ json!(9001),
+ json!(5),
+ json!("Y"),
+ Value::Null,
+ Value::Null,
+ Value::Null,
+ ]],
+ )))
+ })
+ .await;
+ assert_eq!(privileges.len(), 1);
+ assert_eq!(privileges[0].grantee, "ID:7");
+ assert_eq!(privileges[0].privilege, "ID:9001");
+ assert_eq!(privileges[0].grantable, Some(true));
+ assert_eq!(privileges[0].grantor.as_deref(), Some("5"));
+ assert_eq!(privileges[0].column_id.as_deref(), Some("-1"));
+ assert_eq!(read.state, TypeMetadataState::Incomplete);
+ }
+
+ #[test]
+ fn type_sql_plan_api_builds_only_exact_typed_operations() {
+ use crate::db::{OracleTypeManagementSqlInput as Input, OracleTypeManagementSqlOperation as Op};
+ use crate::models::connection::DatabaseType;
+ let source = "CREATE OR REPLACE TYPE \"APP\".\"Mixed Type\" AS OBJECT (ID NUMBER);".to_string();
+ let result = super::super::build_oracle_type_management_sql(Input {
+ database_type: DatabaseType::OceanbaseOracle,
+ operation: Op::SaveSpec,
+ owner: "APP".into(),
+ name: "Mixed Type".into(),
+ source: Some(source.clone()),
+ grantee: None,
+ grantable: false,
+ object_type: None,
+ privilege: None,
+ trigger_enabled: None,
+ })
+ .unwrap();
+ assert_eq!(result.statements, vec![source]);
+
+ let result = super::super::build_oracle_type_management_sql(Input {
+ database_type: DatabaseType::Dameng,
+ operation: Op::DropBody,
+ owner: "APP".into(),
+ name: "Mixed Type".into(),
+ source: None,
+ grantee: None,
+ grantable: false,
+ object_type: None,
+ privilege: None,
+ trigger_enabled: None,
+ })
+ .unwrap();
+ assert_eq!(result.statements, vec!["DROP TYPE BODY \"APP\".\"Mixed Type\" RESTRICT;"]);
+
+ assert!(super::super::build_oracle_type_management_sql(Input {
+ database_type: DatabaseType::Oracle,
+ operation: Op::SaveBody,
+ owner: "APP".into(),
+ name: "Mixed Type".into(),
+ source: Some("CREATE TYPE \"APP\".\"Mixed Type\" AS OBJECT (ID NUMBER);".into()),
+ grantee: None,
+ grantable: false,
+ object_type: None,
+ privilege: None,
+ trigger_enabled: None,
+ })
+ .is_err());
+
+ for database_type in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle, DatabaseType::Dameng] {
+ let compiled = super::super::build_oracle_type_management_sql(Input {
+ database_type,
+ operation: Op::CompileSpec,
+ owner: "APP".into(),
+ name: "Quoted\" Type".into(),
+ source: Some("CREATE TYPE APP.\"Quoted\"\" Type\" AS OBJECT (ID NUMBER);".into()),
+ grantee: None,
+ grantable: false,
+ object_type: None,
+ privilege: None,
+ trigger_enabled: None,
+ });
+ if database_type == DatabaseType::Oracle {
+ let compiled = compiled.unwrap();
+ assert_eq!(compiled.statements, vec!["ALTER TYPE \"APP\".\"Quoted\"\" Type\" COMPILE SPECIFICATION;"]);
+ assert!(compiled.source_fingerprint.is_some());
+ } else {
+ assert!(
+ compiled.is_err(),
+ "Do not generate the ALTER/COMPILE rejected by the OB probe or guess DM syntax"
+ );
+ }
+ }
+ }
+
+ #[tokio::test]
+ async fn type_management_trigger_state_is_independent_from_compilation_and_source() {
+ for state in [Some("ENABLED"), Some("DISABLED"), Some("UNKNOWN"), None] {
+ let object = object_metadata(
+ super::super::oracle_type_details::Dialect::OceanBase,
+ "APP",
+ "TRG",
+ "TRIGGER",
+ |sql| {
+ std::future::ready(Ok(if sql.contains("FROM ALL_OBJECTS") {
+ result(&["OBJECT_ID", "STATUS"], vec![vec![json!(1), json!("VALID")]])
+ } else if sql.contains("FROM ALL_TRIGGERS") {
+ result(&["STATUS"], vec![vec![state.map_or(Value::Null, |s| json!(s))]])
+ } else {
+ result(&["LINE", "POSITION", "TEXT"], vec![])
+ }))
+ },
+ )
+ .await;
+ let value = serde_json::to_value(object).unwrap();
+ assert_eq!(
+ value["triggerEnabled"],
+ match state {
+ Some("ENABLED") => json!(true),
+ Some("DISABLED") => json!(false),
+ _ => Value::Null,
+ }
+ );
+ assert_eq!(
+ value["triggerEnabledRead"]["state"],
+ if matches!(state, Some("ENABLED" | "DISABLED")) { "available" } else { "incomplete" }
+ );
+ }
+ }
+
+ #[test]
+ fn type_management_trigger_api_preserves_state_without_an_enable_disable_window() {
+ use crate::models::connection::DatabaseType;
+ let source = "CREATE OR REPLACE TRIGGER APP.TRG BEFORE INSERT ON APP.DATA BEGIN NULL; END;";
+ for database_type in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle, DatabaseType::Dameng] {
+ for enabled in [false, true] {
+ let input = |operation| {
+ serde_json::from_value(json!({"databaseType": database_type, "operation":operation, "owner":"APP", "name":"TRG", "objectType":"TRIGGER", "source":source, "triggerEnabled":enabled})).unwrap()
+ };
+ let compiled = super::super::build_oracle_type_management_sql(input("compile_trigger")).unwrap();
+ assert_eq!(compiled.statements, vec!["ALTER TRIGGER \"APP\".\"TRG\" COMPILE;"]);
+ let rebuilt = super::super::build_oracle_type_management_sql(input("rebuild_source"));
+ if database_type == DatabaseType::Dameng && !enabled {
+ assert!(rebuilt.is_err());
+ } else {
+ let rebuilt = rebuilt.unwrap();
+ assert_eq!(rebuilt.statements.len(), 1);
+ assert!(rebuilt.source_fingerprint.is_some());
+ if !enabled {
+ assert!(rebuilt.statements[0].contains("DISABLE BEGIN"));
+ }
+ }
+ }
+ }
+ }
+
+ #[tokio::test]
+ async fn type_management_dameng_trigger_state_uses_the_existing_y_n_semantics() {
+ for (state, expected) in [("Y", Some(true)), ("N", Some(false)), ("?", None)] {
+ let object =
+ object_metadata(super::super::oracle_type_details::Dialect::Dameng, "APP", "TRG", "TRIGGER", |sql| {
+ std::future::ready(Ok(if sql.contains("FROM SYSOBJECTS") {
+ result(&["OBJECT_ID", "STATUS"], vec![vec![json!(1), json!("Y")]])
+ } else if sql.contains("FROM ALL_TRIGGERS") {
+ result(&["STATUS"], vec![vec![json!(state)]])
+ } else {
+ result(&["LINE", "POSITION", "TEXT"], vec![])
+ }))
+ })
+ .await;
+ assert_eq!(object.trigger_enabled, expected);
+ assert_eq!(
+ object.trigger_enabled_read.unwrap().state,
+ if expected.is_some() { TypeMetadataState::Available } else { TypeMetadataState::Incomplete }
+ );
+ }
+ }
+
+ #[tokio::test]
+ async fn type_management_native_oracle_warnings_are_not_blocking_compilation_errors() {
+ for invalid in [false, true] {
+ let object =
+ object_metadata(super::super::oracle_type_details::Dialect::Oracle, "APP", "ROOT", "TYPE", |sql| {
+ let response = if sql.contains("FROM ALL_OBJECTS") {
+ result(
+ &["OBJECT_ID", "STATUS"],
+ vec![vec![json!(1), json!(if invalid { "INVALID" } else { "VALID" })]],
+ )
+ } else {
+ let typed = sql.contains("TEXT, ATTRIBUTE");
+ let mut warning = vec![json!(1), json!(1), json!("PLW-06009: compiler warning")];
+ if typed {
+ warning.push(json!("WARNING"));
+ }
+ let mut rows = vec![warning];
+ if invalid {
+ let mut error = vec![json!(2), json!(3), json!("PLS-00201: invalid reference")];
+ if typed {
+ error.push(json!("ERROR"));
+ }
+ rows.push(error);
+ }
+ result(
+ if typed {
+ &["LINE", "POSITION", "TEXT", "ATTRIBUTE"]
+ } else {
+ &["LINE", "POSITION", "TEXT"]
+ },
+ rows,
+ )
+ };
+ std::future::ready(Ok(response))
+ })
+ .await;
+ assert_eq!(object.errors.len(), usize::from(invalid));
+ assert_eq!(object.errors_read.state, TypeMetadataState::Available);
+ assert!(object.errors_read.reason.as_deref().unwrap_or_default().contains("PLW-06009"));
+ }
+ }
+
+ #[tokio::test]
+ async fn type_management_native_oracle_unknown_diagnostic_severity_remains_incomplete() {
+ let object =
+ object_metadata(super::super::oracle_type_details::Dialect::Oracle, "APP", "ROOT", "TYPE", |sql| {
+ std::future::ready(Ok(if sql.contains("FROM ALL_OBJECTS") {
+ result(&["OBJECT_ID", "STATUS"], vec![vec![json!(1), json!("VALID")]])
+ } else {
+ result(
+ &["LINE", "POSITION", "TEXT", "ATTRIBUTE"],
+ vec![vec![json!(1), json!(2), json!("Unclassified diagnostic"), Value::Null]],
+ )
+ }))
+ })
+ .await;
+ assert_eq!(object.errors_read.state, TypeMetadataState::Incomplete);
+ }
+
+ #[tokio::test]
+ async fn actor_identity_is_exact_and_an_unavailable_actor_cannot_restore_grants() {
+ let (user, read) = acting_user(|sql| {
+ assert_eq!(sql, "SELECT USER AS ACTING_USER FROM DUAL");
+ std::future::ready(Ok(result(&["ACTING_USER"], vec![vec![json!("Mixed User")]])))
+ })
+ .await;
+ assert_eq!(user.as_deref(), Some("Mixed User"));
+ assert_eq!(read.state, TypeMetadataState::Available);
+ let (user, read) = acting_user(|_| std::future::ready(Err("session unknown".into()))).await;
+ assert_eq!(user, None);
+ assert_eq!(read.state, TypeMetadataState::Unavailable);
+ }
+
+ #[tokio::test]
+ async fn dameng_grants_resolve_the_original_grantor_without_guessing_numeric_ids() {
+ let (grants, read) =
+ direct_privileges(super::super::oracle_type_details::Dialect::Dameng, "APP", "ROOT", |sql| {
+ assert!(sql.contains("GU.ID = G.GRANTOR"));
+ std::future::ready(Ok(result(
+ &[
+ "URID",
+ "OBJID",
+ "COLID",
+ "PRIVID",
+ "GRANTOR",
+ "GRANTOR_NAME",
+ "GRANTABLE",
+ "GRANTEE",
+ "PRIVILEGE",
+ "PRIVILEGE_TYPE",
+ ],
+ vec![vec![
+ json!(7),
+ json!(11),
+ json!(-1),
+ json!(9001),
+ json!(5),
+ json!("APP"),
+ json!("Y"),
+ json!("ROLE_A"),
+ json!("EXECUTE"),
+ json!(2),
+ ]],
+ )))
+ })
+ .await;
+ assert_eq!(read.state, TypeMetadataState::Available);
+ assert_eq!(grants[0].grantor.as_deref(), Some("APP"));
+ assert_eq!(grants[0].grantable, Some(true));
+ }
+
+ #[tokio::test]
+ async fn object_state_keeps_invalid_even_when_error_dictionary_is_empty() {
+ let object =
+ object_metadata(super::super::oracle_type_details::Dialect::OceanBase, "APP", "ROOT", "TYPE BODY", |sql| {
+ let value = if sql.contains("FROM ALL_OBJECTS") {
+ result(&["OBJECT_ID", "STATUS"], vec![vec![json!(9007199254740993u64), json!("INVALID")]])
+ } else {
+ result(&["LINE", "POSITION", "TEXT"], vec![])
+ };
+ std::future::ready(Ok(value))
+ })
+ .await;
+ assert_eq!(object.exists, Some(true));
+ assert_eq!(object.object_id.as_deref(), Some("9007199254740993"));
+ assert_eq!(object.status.as_deref(), Some("INVALID"));
+ assert!(object.errors.is_empty());
+ assert_eq!(object.errors_read.state, TypeMetadataState::Available);
+ }
+
+ #[tokio::test]
+ async fn object_state_reads_exact_body_errors_without_merging_the_specification() {
+ let object = object_metadata(
+ super::super::oracle_type_details::Dialect::Oracle,
+ "O'wner",
+ "Mixed Type",
+ "TYPE BODY",
+ |sql| {
+ assert!(sql.contains("'O''wner'"));
+ let value = if sql.contains("FROM ALL_OBJECTS") {
+ result(&["OBJECT_ID", "STATUS"], vec![vec![json!(8), json!("INVALID")]])
+ } else {
+ assert!(sql.contains("TYPE='TYPE BODY'"));
+ result(
+ &["LINE", "POSITION", "TEXT", "ATTRIBUTE"],
+ vec![vec![json!(2), json!(74), json!("Identifier was not declared"), json!("ERROR")]],
+ )
+ };
+ std::future::ready(Ok(value))
+ },
+ )
+ .await;
+ assert_eq!(
+ object.errors,
+ vec![OracleTypeManagementError { line: 2, position: 74, text: "Identifier was not declared".into() }]
+ );
+ }
+
+ #[tokio::test]
+ async fn object_state_distinguishes_verified_absence_unknown_and_duplicate_identity() {
+ for (value, expected_exists, expected_state) in [
+ (Ok(result(&["OBJECT_ID", "STATUS"], vec![])), Some(false), TypeMetadataState::Available),
+ (Err("No catalogue permission".to_string()), None, TypeMetadataState::Unavailable),
+ (
+ Ok(result(
+ &["OBJECT_ID", "STATUS"],
+ vec![vec![json!(1), json!("VALID")], vec![json!(2), json!("VALID")]],
+ )),
+ None,
+ TypeMetadataState::Incomplete,
+ ),
+ ] {
+ let mut calls = 0;
+ let object =
+ object_metadata(super::super::oracle_type_details::Dialect::Oracle, "APP", "ROOT", "TYPE", |_| {
+ calls += 1;
+ std::future::ready(value.clone())
+ })
+ .await;
+ assert_eq!(object.exists, expected_exists);
+ assert_eq!(object.status_read.state, expected_state);
+ assert_eq!(calls, 1);
+ }
+ }
+
+ #[tokio::test]
+ async fn incomplete_dictionary_cells_or_pages_cannot_prove_an_object_state() {
+ for (truncated, has_more, id) in
+ [(true, false, json!(1)), (false, true, json!(1)), (false, false, json!({"preview":"1","truncated":true}))]
+ {
+ let mut value = result(&["OBJECT_ID", "STATUS"], vec![vec![id, json!("VALID")]]);
+ value.truncated = truncated;
+ value.has_more = has_more;
+ let object =
+ object_metadata(super::super::oracle_type_details::Dialect::Oracle, "APP", "ROOT", "TYPE", |_| {
+ std::future::ready(Ok(value.clone()))
+ })
+ .await;
+ assert_eq!(object.exists, None);
+ assert_eq!(object.status_read.state, TypeMetadataState::Incomplete);
+ }
+ }
+}
diff --git a/crates/dbx-core/src/schema/oracle_type_transport_tests.rs b/crates/dbx-core/src/schema/oracle_type_transport_tests.rs
new file mode 100644
index 0000000000..b57f5c81fd
--- /dev/null
+++ b/crates/dbx-core/src/schema/oracle_type_transport_tests.rs
@@ -0,0 +1,579 @@
+use super::{get_custom_type_details_core, AppState, ConnectionConfig, DatabaseType, PoolKind};
+use crate::db::agent_driver::{AgentDriverClient, AgentLaunchSpec, AgentRuntimeClient};
+use serde_json::{json, Value};
+#[cfg(unix)]
+use std::sync::Arc;
+use std::time::Duration;
+
+// Both real transports reach the same external query boundary. Any use of an
+// unsupported getCustomTypeDetails/get_custom_type_details RPC is an error.
+const SCRIPT: &str = r#"#!/usr/bin/env python3
+import json, pathlib, re, sys
+oceanbase = 'oceanbase' in pathlib.Path(__file__).stem
+migration = 'migration' in pathlib.Path(__file__).stem
+persisted = 'persisted' in pathlib.Path(__file__).stem
+missing = 'missing' in pathlib.Path(__file__).stem
+invalid_body = 'invalid-body' in pathlib.Path(__file__).stem
+large_values = 'large-values' in pathlib.Path(__file__).stem
+if '--agent' in sys.argv or pathlib.Path(__file__).name in ('agent', 'agent.exe'):
+ print(json.dumps({'ready': True}), flush=True)
+def query(sql):
+ if sql == 'SELECT USER AS ACTING_USER FROM DUAL':
+ return ['ACTING_USER'], [['APP']]
+ if 'SELECT OBJECT_ID, STATUS FROM ALL_OBJECTS' in sql:
+ if missing and "'Detached Caller'" not in sql:
+ rows = []
+ elif "OBJECT_TYPE='TYPE BODY'" in sql:
+ rows = [[12,'INVALID']] if invalid_body and "'Mixed Type'" in sql else []
+ else:
+ rows = [[2 if "'COLL'" in sql else 1, 'VALID']]
+ return ['OBJECT_ID', 'STATUS'], rows
+ if 'FROM ALL_OBJECTS ' in sql:
+ rows = [['APP', 'Mixed Type', 'TYPE', 'VALID']]
+ if invalid_body: rows.append(['APP','Mixed Type','TYPE BODY','INVALID'])
+ return ['OWNER', 'OBJECT_NAME', 'OBJECT_TYPE', 'STATUS'], rows
+ if 'FROM ALL_TYPES ' in sql:
+ return ['OWNER', 'TYPE_NAME', 'TYPECODE', 'ATTRIBUTES', 'METHODS', 'FINAL', 'INSTANTIABLE', 'SUPERTYPE_OWNER', 'SUPERTYPE_NAME'], [['APP', 'Mixed Type', 'OBJECT', 2 if oceanbase else 0, 1 if oceanbase else 0, 'YES', 'YES', None, None]]
+ if 'FROM ALL_TYPE_ATTRS ' in sql:
+ if oceanbase:
+ return ['OWNER', 'TYPE_NAME', 'ATTR_NAME', 'ATTR_NO', 'ATTR_TYPE_OWNER', 'ATTR_TYPE_NAME', 'LENGTH', 'NUMBER_PRECISION', 'SCALE'], [['APP', 'Mixed Type', 'ID', 1, None, 'NUMBER', -1, -1, -85], ['APP', 'Mixed Type', 'LABEL', 2, None, 'VARCHAR2', 40, 2, -1]]
+ return ['OWNER', 'TYPE_NAME', 'ATTR_NAME', 'ATTR_NO', 'ATTR_TYPE_OWNER', 'ATTR_TYPE_NAME', 'LENGTH', 'PRECISION', 'SCALE'], []
+ if 'FROM ALL_TYPE_METHODS ' in sql:
+ return ['OWNER', 'TYPE_NAME', 'METHOD_NAME', 'METHOD_NO', 'METHOD_TYPE', 'PARAMETERS', 'RESULTS'], []
+ if 'FROM ALL_COLL_TYPES ' in sql:
+ return ['OWNER', 'TYPE_NAME', 'COLL_TYPE', 'ELEM_TYPE_OWNER', 'ELEM_TYPE_NAME', 'LENGTH', 'PRECISION', 'SCALE'], []
+ if 'FROM ALL_DEPENDENCIES ' in sql:
+ rows = [['APP', 'COLL', 'TYPE', 'APP', 'Mixed Type', 'TYPE', None]] if migration and "REFERENCED_TYPE = 'TYPE'" in sql and "'Mixed Type'" in sql else []
+ return ['OWNER', 'NAME', 'TYPE', 'REFERENCED_OWNER', 'REFERENCED_NAME', 'REFERENCED_TYPE', 'REFERENCED_LINK_NAME'], rows
+ if 'FROM ALL_TAB_COLUMNS ' in sql:
+ rows = [['APP','DATA','VALUE','APP','COLL','NO']] if persisted and "C.DATA_TYPE = 'COLL'" in sql else []
+ return ['OWNER', 'TABLE_NAME', 'COLUMN_NAME', 'DATA_TYPE_OWNER', 'DATA_TYPE', 'READ_ONLY'], rows
+ if 'FROM ALL_ERRORS ' in sql:
+ typed = 'TEXT, ATTRIBUTE' in sql
+ rows = [[1,74,'Identifier was not declared'] + (['ERROR'] if typed else [])] if invalid_body and "TYPE='TYPE BODY'" in sql else []
+ return ['LINE','POSITION','TEXT'] + (['ATTRIBUTE'] if typed else []), rows
+ if 'FROM ALL_TAB_PRIVS ' in sql:
+ rows = [['APP', 'MIG_OTHER', 'EXECUTE', 'YES', 'NO']] if migration else []
+ return ['GRANTOR', 'GRANTEE', 'PRIVILEGE', 'GRANTABLE', 'HIERARCHY'], rows
+ if 'DBMS_METADATA.GET_DDL' in sql:
+ return ['DDL'], [['CREATE TYPE APP.\\"Mixed Type\\" AS OBJECT (ID NUMBER);']]
+ raise Exception('unexpected query')
+for line in sys.stdin:
+ request = json.loads(line)
+ method, params = request['method'], request.get('params', {})
+ with pathlib.Path(__file__).with_name('calls.jsonl').open('a') as log:
+ log.write(json.dumps(request) + '\n')
+ if method == 'handshake':
+ result = {'protocolVersion': 2, 'agentProtocolVersion': 2, 'capabilities': ['multi_session']}
+ elif method in ('execute_query', 'executeQuery'):
+ if 'FROM all_objects ' in params['sql']:
+ sql = params['sql']
+ owner = re.search(r"OR \(o\.owner = '((?:''|[^'])*)' AND o\.object_type IN \('TYPE', 'TYPE BODY'\)", sql).group(1).replace("''", "'")
+ rows = [[f'A{index:04}', 'TYPE', owner, None, None] for index in range(999)]
+ rows += [['Mixed Type', 'TYPE', owner, None, None], ['Mixed Type', 'TYPE_BODY', owner, None, None]]
+ start = int(re.search(r'dbx_row_number > (\d+)', sql).group(1))
+ end = int(re.search(r'ROWNUM <= (\d+)', sql).group(1))
+ result = {'columns': ['OBJECT_NAME', 'OBJECT_TYPE', 'OWNER', 'PARENT_SCHEMA', 'PARENT_NAME'], 'rows': rows[start:end], 'truncated': False, 'affected_rows': 0, 'execution_time_ms': 0}
+ else:
+ columns, rows = query(params['sql'])
+ result = {'columns': columns, 'rows': rows, 'affected_rows': 0, 'execution_time_ms': 0}
+ if large_values and rows and 'FROM ALL_ERRORS ' in params['sql']:
+ result['large_value_cells'] = [{'row_index':0,'column_index':2,'original_bytes':4096}]
+ elif method == 'get_object_source':
+ quoted_name = '"' + params['name'].replace('"','""') + '"'
+ source = 'CREATE TYPE APP.' + quoted_name + (' AS TABLE OF APP."Mixed Type";' if params['name']=='COLL' else ' AS OBJECT (ID NUMBER);')
+ if params['object_type'] == 'FUNCTION': source = 'CREATE FUNCTION APP.' + quoted_name + '(P NUMBER) RETURN NUMBER IS BEGIN RETURN P; END;'
+ if params['object_type'] == 'TYPE_BODY': source = 'CREATE TYPE BODY APP.' + quoted_name + ' AS MEMBER FUNCTION F RETURN NUMBER IS BEGIN RETURN NO_SUCH_IDENTIFIER; END; END;'
+ result = {'name': params['name'], 'object_type': params['object_type'], 'schema': params['schema'], 'source': source}
+ elif method == 'list_objects':
+ result = [{'name': 'Mixed Type', 'object_type': kind, 'schema': params['schema']} for kind in ('TYPE', 'TYPE_BODY')]
+ if params.get('object_types'):
+ result = [row for row in result if row['object_type'] in params['object_types']]
+ offset, limit = params.get('offset', 0), params.get('limit', 0)
+ result = result[offset:offset+limit] if limit else result[offset:]
+ elif method in ('open_session', 'connect', 'close_session', 'close', 'disconnect', 'ping'):
+ result = {}
+ else:
+ print(json.dumps({'id': request['id'], 'error': {'code': -1, 'message': 'unsupported fixture RPC: ' + method}}), flush=True)
+ continue
+ print(json.dumps({'jsonrpc': '2.0', 'id': request['id'], 'result': result}), flush=True)
+"#;
+
+async fn state(dir: &std::path::Path) -> AppState {
+ AppState::new(crate::persistence::test_storage::open(&dir.join("storage.db")).await.unwrap())
+}
+
+#[tokio::test]
+async fn type_management_native_endpoint_denies_ob_and_dm_without_starting_a_query_transport() {
+ for (db_type, url) in [
+ (DatabaseType::OceanbaseOracle, "jdbc:oracle:thin:@127.0.0.1:1521/app"),
+ (DatabaseType::Dameng, "jdbc:dm://127.0.0.1:5236"),
+ (DatabaseType::Jdbc, "jdbc:oceanbase:oracle://127.0.0.1:2881/app"),
+ (DatabaseType::Jdbc, "jdbc:dm://127.0.0.1:5236"),
+ ] {
+ let dir = tempfile::tempdir().unwrap();
+ let state = state(dir.path()).await;
+ let mut config = config(db_type);
+ config.connection_string = Some(url.into());
+ state.configs.write().await.insert(config.id.clone(), config);
+ let result = super::prepare_oracle_type_evolution_core(
+ &state,
+ crate::db::OracleTypeEvolutionRequest {
+ target: crate::db::OracleTypeManagementTarget {
+ connection_id: "type-transport".into(),
+ database: "app".into(),
+ owner: "APP".into(),
+ name: "ROOT".into(),
+ },
+ source_before: "CREATE TYPE APP.ROOT AS OBJECT(ID NUMBER);".into(),
+ source_after: "CREATE TYPE APP.ROOT AS OBJECT(ID NUMBER, EXTRA RAW(8));".into(),
+ manifest: None,
+ },
+ )
+ .await;
+ assert!(result.unwrap_err().contains("not enabled for this database dialect"));
+ assert!(!dir.path().join("calls.jsonl").exists());
+ }
+}
+
+fn config(db_type: DatabaseType) -> ConnectionConfig {
+ serde_json::from_value(json!({
+ "id": "type-transport", "name": "Type transport test", "db_type": db_type,
+ "host": "127.0.0.1", "port": 1521, "username": "fixture", "password": "",
+ "database": "app", "query_timeout_secs": 2, "keepalive_interval_secs": 0,
+ "connection_string": "jdbc:oracle:thin:@127.0.0.1:1521/app"
+ }))
+ .unwrap()
+}
+
+fn assert_queries(dir: &std::path::Path, method: &str) {
+ let requests: Vec<Value> = std::fs::read_to_string(dir.join("calls.jsonl"))
+ .unwrap()
+ .lines()
+ .map(|line| serde_json::from_str(line).unwrap())
+ .collect();
+ assert!(requests.iter().all(|request| !matches!(
+ request["method"].as_str(),
+ Some("getCustomTypeDetails" | "get_custom_type_details")
+ )));
+ let queries: Vec<_> = requests.iter().filter(|request| request["method"] == method).collect();
+ assert_eq!(queries.len(), 5);
+ for query in queries {
+ assert_eq!(query["params"]["database"], "app");
+ assert!(query["params"].get("schema").is_none(), "dictionary reads must not request a session schema switch");
+ assert!(query["params"]["sql"].as_str().unwrap().contains("= 'Mixed Type'"));
+ }
+}
+
+fn assert_dictionary_details(details: crate::db::CustomTypeDetails) {
+ use crate::db::TypeMetadataState;
+ assert_eq!(details.name, "Mixed Type");
+ assert_eq!(details.schema, "APP");
+ assert_eq!(details.kind, crate::db::CustomTypeKind::Object);
+ assert!(details.ddl.is_none());
+ let metadata = details.oracle_metadata.unwrap();
+ assert_eq!(metadata.body_visible, Some(false));
+ assert_eq!(metadata.attribute_count, Some(0));
+ assert_eq!(metadata.method_count, Some(0));
+ for section in [
+ metadata.properties_read,
+ metadata.body_read,
+ metadata.attributes_read,
+ metadata.methods_read,
+ metadata.collection_read,
+ ] {
+ assert_eq!(section.state, TypeMetadataState::Available);
+ assert!(section.reason.is_none());
+ }
+ assert!(metadata.attributes.is_empty() && metadata.methods.is_empty() && metadata.collection.is_none());
+}
+
+#[tokio::test]
+async fn agent_type_details_use_existing_query_rpc_before_the_pg_details_rpc() {
+ let dir = tempfile::tempdir().unwrap();
+ let script = dir.path().join("type-agent.py");
+ std::fs::write(&script, SCRIPT).unwrap();
+ let python = if cfg!(windows) { "python" } else { "python3" };
+ let runtime = AgentRuntimeClient::spawn(
+ AgentLaunchSpec::new(python).with_args([script.to_string_lossy().to_string(), "--agent".to_string()]),
+ "test",
+ )
+ .await
+ .unwrap();
+ runtime.increment_session_count();
+ let state = state(dir.path()).await;
+ let config = config(DatabaseType::Oracle);
+ state.configs.write().await.insert(config.id.clone(), config);
+ state
+ .update_connection_pools(|pools| {
+ pools.insert(
+ "type-transport:role:metadata".into(),
+ PoolKind::agent(AgentDriverClient::shared_session(runtime.clone(), "metadata-session".into())),
+ );
+ })
+ .await;
+ let details = get_custom_type_details_core(&state, "type-transport", "app", "APP", "Mixed Type").await.unwrap();
+ assert_dictionary_details(details);
+ assert_queries(dir.path(), "execute_query");
+ state.shutdown(Duration::from_secs(2)).await;
+ runtime.kill();
+}
+
+#[cfg(unix)]
+#[tokio::test]
+async fn legacy_oracle_type_lists_use_server_paging_and_full_schema_reads_do_not_drop_later_types() {
+ use std::os::unix::fs::PermissionsExt;
+ let dir = tempfile::tempdir().unwrap();
+ let storage = crate::persistence::test_storage::open(&dir.path().join("storage.db")).await.unwrap();
+ let state = AppState::new_with_plugin_and_agent_dir_and_app_version(
+ storage,
+ dir.path().join("plugins"),
+ dir.path().join("agents"),
+ "test",
+ );
+ let script = state.agent_manager.driver_native_path("oracle");
+ std::fs::create_dir_all(script.parent().unwrap()).unwrap();
+ std::fs::write(&script, SCRIPT).unwrap();
+ std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let mut config = config(DatabaseType::Oracle);
+ config.port = listener.local_addr().unwrap().port();
+ config.driver_profile = Some("oracle-legacy".into());
+ state.configs.write().await.insert(config.id.clone(), config);
+ let kinds = ["TYPE".to_string(), "TYPE_BODY".to_string()];
+ let schema = " Exact O'wner ";
+ let page = super::list_objects_core(
+ &state,
+ "type-transport",
+ "app",
+ schema,
+ Some("Mixed"),
+ Some(1),
+ Some(1),
+ Some(&kinds),
+ None,
+ )
+ .await
+ .unwrap();
+ assert_eq!(page.len(), 1);
+ assert_eq!(page[0].object_type, "TYPE_BODY");
+ assert_eq!(page[0].schema.as_deref(), Some(schema));
+ let all =
+ super::list_objects_core(&state, "type-transport", "app", schema, None, None, None, None, None).await.unwrap();
+ assert_eq!(all.len(), 1001);
+ assert!(all.iter().all(|object| object.schema.as_deref() == Some(schema)));
+ assert_eq!(
+ all.iter()
+ .filter(|object| object.name == "Mixed Type")
+ .map(|object| object.object_type.as_str())
+ .collect::<Vec<_>>(),
+ ["TYPE", "TYPE_BODY"]
+ );
+ let calls: Vec<Value> = std::fs::read_to_string(script.with_file_name("calls.jsonl"))
+ .unwrap()
+ .lines()
+ .map(|line| serde_json::from_str(line).unwrap())
+ .collect();
+ let typed = calls.iter().find(|call| call["method"] == "list_objects").unwrap();
+ assert_eq!(typed["params"]["schema"], schema);
+ assert_eq!(typed["params"]["limit"], 1);
+ assert_eq!(typed["params"]["offset"], 1);
+ assert_eq!(typed["params"]["filter"], "Mixed");
+ let queries: Vec<_> = calls.iter().filter(|call| call["method"] == "execute_query").collect();
+ assert_eq!(queries.len(), 2);
+ for (query, start) in queries.iter().zip([0, 1000]) {
+ assert!(query["params"].get("schema").is_none());
+ assert!(query["params"].get("rowOffset").is_none());
+ let sql = query["params"]["sql"].as_str().unwrap();
+ assert!(sql.contains(&format!("ROWNUM <= {}", start + 1000)));
+ assert!(sql.contains(&format!("dbx_row_number > {start}")));
+ assert!(sql.contains("o.owner = ' Exact O''wner ' AND o.object_type IN ('TYPE', 'TYPE BODY')"));
+ }
+ state.shutdown(Duration::from_secs(2)).await;
+}
+
+#[cfg(unix)]
+#[tokio::test]
+async fn external_driver_type_details_return_the_same_dictionary_result_via_execute_query() {
+ use crate::plugins::{
+ InstalledPlugin, PluginCompatibility, PluginDriverManifest, PluginDriverSession, PluginManifest,
+ PluginRuntimeEnv,
+ };
+ use std::os::unix::fs::PermissionsExt;
+ for oceanbase in [false, true] {
+ let dir = tempfile::tempdir().unwrap();
+ let executable = if oceanbase { "type-plugin-oceanbase.py" } else { "type-plugin.py" };
+ let script = dir.path().join(executable);
+ std::fs::write(&script, SCRIPT).unwrap();
+ std::fs::set_permissions(&script, 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(executable.into()),
+ drivers: vec![PluginDriverManifest {
+ id: "jdbc".into(),
+ label: "JDBC".into(),
+ kind: "external".into(),
+ database_type: Some("jdbc".into()),
+ }],
+ ..PluginManifest::default()
+ },
+ path: dir.path().to_path_buf(),
+ compatibility: PluginCompatibility {
+ compatible: true,
+ backend_executable: Some(script),
+ ..PluginCompatibility::default()
+ },
+ provenance: None,
+ };
+ let session = Arc::new(
+ PluginDriverSession::start_for_test(plugin, "jdbc".into(), PluginRuntimeEnv::default()).await.unwrap(),
+ );
+ let state = state(dir.path()).await;
+ let mut config = config(DatabaseType::Jdbc);
+ if oceanbase {
+ config.connection_string = Some(" JDBC:OceanBase:Oracle://127.0.0.1:2881/app ".into());
+ config.jdbc_driver_class = Some("com.oceanbase.jdbc.Driver".into());
+ }
+ state.configs.write().await.insert(config.id.clone(), config.clone());
+ state
+ .update_connection_pools(|pools| {
+ pools.insert(
+ config.id.clone(),
+ PoolKind::ExternalDriver { driver_id: "jdbc".into(), config: Arc::new(config), session },
+ );
+ })
+ .await;
+ let details = get_custom_type_details_core(&state, "type-transport", "app", "APP", "Mixed Type").await.unwrap();
+ if oceanbase {
+ let metadata = details.oracle_metadata.unwrap();
+ assert_eq!(metadata.attribute_count, Some(2));
+ assert_eq!(metadata.attributes.len(), 2);
+ assert_eq!(metadata.attributes[0].length, None);
+ assert_eq!(metadata.attributes[0].precision, None);
+ assert_eq!(metadata.attributes[0].scale, None);
+ assert_eq!(metadata.attributes[1].length, Some(40));
+ assert_eq!(metadata.attributes[1].precision, None);
+ assert_eq!(metadata.attributes[1].scale, None);
+ assert_eq!(metadata.methods_read.state, crate::db::TypeMetadataState::Incomplete);
+ } else {
+ assert_dictionary_details(details);
+ }
+ assert_queries(dir.path(), "executeQuery");
+ state.shutdown(Duration::from_secs(2)).await;
+ }
+}
+
+#[tokio::test]
+async fn type_management_snapshot_keeps_out_of_band_large_cell_previews_incomplete() {
+ let dir = tempfile::tempdir().unwrap();
+ let script = dir.path().join("type-management-large-values-invalid-body-agent.py");
+ std::fs::write(&script, SCRIPT).unwrap();
+ let python = if cfg!(windows) { "python" } else { "python3" };
+ let runtime = AgentRuntimeClient::spawn(
+ AgentLaunchSpec::new(python).with_args([script.to_string_lossy().to_string(), "--agent".into()]),
+ "test",
+ )
+ .await
+ .unwrap();
+ runtime.increment_session_count();
+ let state = state(dir.path()).await;
+ let config = config(DatabaseType::Oracle);
+ state.configs.write().await.insert(config.id.clone(), config);
+ state
+ .update_connection_pools(|pools| {
+ pools.insert(
+ "type-transport:role:metadata".into(),
+ PoolKind::agent(AgentDriverClient::shared_session(runtime.clone(), "metadata-session".into())),
+ );
+ })
+ .await;
+ let snapshot =
+ super::get_oracle_type_management_snapshot_core(&state, "type-transport", "app", "APP", "Mixed Type")
+ .await
+ .unwrap();
+ let body = snapshot.objects.iter().find(|object| object.object_type == "TYPE BODY").unwrap();
+ let actual = body.errors_read.state.clone();
+ state.shutdown(Duration::from_secs(2)).await;
+ runtime.kill();
+ assert_eq!(
+ actual,
+ crate::db::TypeMetadataState::Incomplete,
+ "A deferred string preview is not a complete compilation diagnostic or scalar value"
+ );
+}
+
+#[tokio::test]
+async fn type_management_snapshot_uses_the_existing_query_transport_and_keeps_sections_independent() {
+ let dir = tempfile::tempdir().unwrap();
+ let script = dir.path().join("type-management-agent.py");
+ std::fs::write(&script, SCRIPT).unwrap();
+ let python = if cfg!(windows) { "python" } else { "python3" };
+ let runtime = AgentRuntimeClient::spawn(
+ AgentLaunchSpec::new(python).with_args([script.to_string_lossy().to_string(), "--agent".to_string()]),
+ "test",
+ )
+ .await
+ .unwrap();
+ runtime.increment_session_count();
+ let state = state(dir.path()).await;
+ let config = config(DatabaseType::Oracle);
+ state.configs.write().await.insert(config.id.clone(), config);
+ state
+ .update_connection_pools(|pools| {
+ pools.insert(
+ "type-transport:role:metadata".into(),
+ PoolKind::agent(AgentDriverClient::shared_session(runtime.clone(), "metadata-session".into())),
+ );
+ })
+ .await;
+ let snapshot =
+ super::get_oracle_type_management_snapshot_core(&state, "type-transport", "app", "APP", "Mixed Type")
+ .await
+ .unwrap();
+ assert_eq!(snapshot.target.owner, "APP");
+ assert!(
+ snapshot.type_source.as_deref().is_some_and(|source| source.contains("CREATE TYPE")),
+ "unexpected type source read: {:?}",
+ snapshot.type_source_read
+ );
+ assert_eq!(snapshot.type_source_read.state, crate::db::TypeMetadataState::Available);
+ assert!(snapshot.body_source.is_none());
+ assert_eq!(snapshot.body_source_read.state, crate::db::TypeMetadataState::Available);
+ assert!(snapshot.dependencies.is_empty());
+ assert_eq!(snapshot.dependencies_read.state, crate::db::TypeMetadataState::Available);
+ assert_eq!(snapshot.persistent_references_read.state, crate::db::TypeMetadataState::Available);
+ assert_eq!(snapshot.privileges_read.state, crate::db::TypeMetadataState::Available);
+ let requests: Vec<Value> = std::fs::read_to_string(dir.path().join("calls.jsonl"))
+ .unwrap()
+ .lines()
+ .map(|line| serde_json::from_str(line).unwrap())
+ .collect();
+ assert!(requests.iter().all(|request| !matches!(
+ request["method"].as_str(),
+ Some("getCustomTypeDetails" | "get_custom_type_details")
+ )));
+ let queries: Vec<_> = requests.iter().filter(|request| request["method"] == "execute_query").collect();
+ assert!(queries.iter().any(|query| query["params"]["sql"].as_str().unwrap().contains("ALL_DEPENDENCIES")));
+ assert!(queries.iter().any(|query| query["params"]["sql"].as_str().unwrap().contains("TABLE_SCHEMA")));
+ assert!(requests.iter().any(|request| request["method"] == "get_object_source"));
+ let root = snapshot.objects.iter().find(|object| object.object_type == "TYPE").unwrap();
+ assert_eq!(root.exists, Some(true));
+ assert_eq!(root.object_id.as_deref(), Some("1"));
+ assert_eq!(root.status.as_deref(), Some("VALID"));
+ assert!(root.errors.is_empty());
+ state.shutdown(Duration::from_secs(2)).await;
+ runtime.kill();
+}
+
+#[tokio::test]
+async fn snapshot_reads_direct_grants_for_a_dependent_type_that_may_be_rebuilt() {
+ let dir = tempfile::tempdir().unwrap();
+ let script = dir.path().join("type-management-migration-agent.py");
+ std::fs::write(&script, SCRIPT).unwrap();
+ let python = if cfg!(windows) { "python" } else { "python3" };
+ let runtime = AgentRuntimeClient::spawn(
+ AgentLaunchSpec::new(python).with_args([script.to_string_lossy().to_string(), "--agent".to_string()]),
+ "test",
+ )
+ .await
+ .unwrap();
+ runtime.increment_session_count();
+ let state = state(dir.path()).await;
+ let config = config(DatabaseType::Oracle);
+ state.configs.write().await.insert(config.id.clone(), config);
+ state
+ .update_connection_pools(|pools| {
+ pools.insert(
+ "type-transport:role:metadata".into(),
+ PoolKind::agent(AgentDriverClient::shared_session(runtime.clone(), "metadata-session".into())),
+ );
+ })
+ .await;
+ let snapshot =
+ super::get_oracle_type_management_snapshot_core(&state, "type-transport", "app", "APP", "Mixed Type")
+ .await
+ .unwrap();
+ assert_eq!(snapshot.direct_privileges.len(), 1);
+ let dependent = snapshot.objects.iter().find(|object| object.name == "COLL").unwrap();
+ assert_eq!(dependent.object_type, "TYPE");
+ assert_eq!(dependent.privileges_read.state, crate::db::TypeMetadataState::Available);
+ assert_eq!(dependent.direct_privileges.len(), 1);
+ assert_eq!(dependent.direct_privileges[0].grantee, "MIG_OTHER");
+ assert_eq!(dependent.direct_privileges[0].privilege, "EXECUTE");
+ assert_eq!(dependent.direct_privileges[0].grantable, Some(true));
+ state.shutdown(Duration::from_secs(2)).await;
+ runtime.kill();
+}
+
+#[tokio::test]
+async fn type_management_snapshot_retains_diagnostics_indirect_values_and_known_recovery_targets() {
+ use crate::db::{OracleTypeManagementObjectKey, TypeMetadataState};
+ for scenario in ["invalid-body", "persisted-migration", "missing"] {
+ let dir = tempfile::tempdir().unwrap();
+ let script = dir.path().join(format!("type-management-{scenario}-agent.py"));
+ std::fs::write(&script, SCRIPT).unwrap();
+ let runtime = AgentRuntimeClient::spawn(
+ AgentLaunchSpec::new(if cfg!(windows) { "python" } else { "python3" })
+ .with_args([script.to_string_lossy().to_string(), "--agent".into()]),
+ "test",
+ )
+ .await
+ .unwrap();
+ runtime.increment_session_count();
+ let state = state(dir.path()).await;
+ state.configs.write().await.insert("type-transport".into(), config(DatabaseType::Oracle));
+ state
+ .update_connection_pools(|pools| {
+ pools.insert(
+ "type-transport:role:metadata".into(),
+ PoolKind::agent(AgentDriverClient::shared_session(runtime.clone(), "metadata-session".into())),
+ );
+ })
+ .await;
+ let known = if scenario == "missing" {
+ vec![OracleTypeManagementObjectKey {
+ owner: "APP".into(),
+ name: "Detached Caller".into(),
+ object_type: "FUNCTION".into(),
+ }]
+ } else {
+ vec![]
+ };
+ let snapshot = super::get_oracle_type_management_snapshot_with_objects_core(
+ &state,
+ "type-transport",
+ "app",
+ "APP",
+ "Mixed Type",
+ &known,
+ )
+ .await
+ .unwrap();
+ if scenario == "invalid-body" {
+ let body = snapshot.objects.iter().find(|object| object.object_type == "TYPE BODY").unwrap();
+ assert_eq!(body.status.as_deref(), Some("INVALID"));
+ assert_eq!(body.errors_read.state, TypeMetadataState::Available);
+ assert_eq!(body.errors[0].position, 74);
+ assert!(snapshot.body_source.as_deref().unwrap().contains("NO_SUCH_IDENTIFIER"));
+ } else if scenario == "persisted-migration" {
+ assert_eq!(snapshot.persistent_references.len(), 1);
+ assert_eq!(snapshot.persistent_references[0].data_type.as_deref(), Some("COLL"));
+ assert_eq!(snapshot.persistent_references_read.state, TypeMetadataState::Available);
+ } else {
+ assert!(snapshot.details.is_none());
+ assert!(snapshot.type_source.is_none());
+ assert_eq!(snapshot.details_read.state, TypeMetadataState::Available);
+ let root = snapshot.objects.iter().find(|object| object.object_type == "TYPE").unwrap();
+ assert_eq!(root.exists, Some(false));
+ let caller = snapshot.objects.iter().find(|object| object.name == "Detached Caller").unwrap();
+ assert_eq!(caller.exists, Some(true));
+ assert!(caller.source.as_deref().unwrap().contains("CREATE FUNCTION"));
+ }
+ state.shutdown(Duration::from_secs(2)).await;
+ runtime.kill();
+ }
+}
diff --git a/crates/dbx-core/tests/agent_service.rs b/crates/dbx-core/tests/agent_service.rs
index c4704db5bb..a070e7f456 100644
--- a/crates/dbx-core/tests/agent_service.rs
+++ b/crates/dbx-core/tests/agent_service.rs
@@ -1476,10 +1476,19 @@ fn write_test_agent_jar(path: &std::path::Path) {
std::fs::write(path, test_agent_jar_bytes()).unwrap();
}
+#[test]
+fn agent_jar_fixture_uses_a_fixed_entry_timestamp() {
+ let bytes = test_agent_jar_bytes();
+ let mut archive = zip::ZipArchive::new(std::io::Cursor::new(bytes)).unwrap();
+ assert_eq!(archive.by_name("META-INF/MANIFEST.MF").unwrap().last_modified(), Some(zip::DateTime::default()));
+}
+
fn test_agent_jar_bytes() -> Vec<u8> {
let cursor = std::io::Cursor::new(Vec::new());
let mut zip = zip::ZipWriter::new(cursor);
- let options = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
+ let options = zip::write::SimpleFileOptions::default()
+ .compression_method(zip::CompressionMethod::Stored)
+ .last_modified_time(zip::DateTime::default());
// The production validator rejects corrupt driver artifacts by requiring a real JAR manifest.
zip.start_file("META-INF/MANIFEST.MF", options).unwrap();
std::io::Write::write_all(&mut zip, b"Manifest-Version: 1.0\nMain-Class: com.dbx.agent.TestAgent\n\n").unwrap();
diff --git a/crates/dbx-driver-postgres/src/postgres.rs b/crates/dbx-driver-postgres/src/postgres.rs
index aa148cd925..2c268946aa 100644
--- a/crates/dbx-driver-postgres/src/postgres.rs
+++ b/crates/dbx-driver-postgres/src/postgres.rs
@@ -7897,6 +7897,11 @@ fn build_custom_type_ddl(
warnings: all,
}
}
+ CustomTypeKind::Object | CustomTypeKind::Collection | CustomTypeKind::Other => CustomTypeDdl {
+ sql: String::new(),
+ complete: false,
+ warnings: vec!["Not a PostgreSQL custom type category".to_string()],
+ },
}
}
@@ -7971,6 +7976,9 @@ pub async fn get_custom_type_details(pool: &Pool, schema: &str, name: &str) -> R
warnings.extend(custom_type_range_attributes(client, info.oid, true, &mut properties).await);
}
CustomTypeKind::Base => {}
+ CustomTypeKind::Object | CustomTypeKind::Collection | CustomTypeKind::Other => {
+ return Err("not a PostgreSQL custom type category".to_string());
+ }
}
let ddl = build_custom_type_ddl(schema, name, kind, &info, &members, &properties, &warnings);
@@ -7982,6 +7990,7 @@ pub async fn get_custom_type_details(pool: &Pool, schema: &str, name: &str) -> R
members,
properties,
ddl: Some(ddl),
+ oracle_metadata: None,
})
}
diff --git a/crates/dbx-sql-core/src/lib.rs b/crates/dbx-sql-core/src/lib.rs
index c08943fab1..5f24c0e837 100644
--- a/crates/dbx-sql-core/src/lib.rs
+++ b/crates/dbx-sql-core/src/lib.rs
@@ -8,6 +8,7 @@ pub mod dml_preview_sql;
pub mod mysql_ddl_normalize;
pub mod mysql_event_sql;
pub mod object_source_sql;
+pub mod oracle_type_migration_sql;
pub mod oracle_view_rename;
pub mod query_execution_sql;
pub mod sql;
diff --git a/crates/dbx-sql-core/src/object_source_sql.rs b/crates/dbx-sql-core/src/object_source_sql.rs
index 3a833dd158..45e046f82b 100644
--- a/crates/dbx-sql-core/src/object_source_sql.rs
+++ b/crates/dbx-sql-core/src/object_source_sql.rs
@@ -5,7 +5,7 @@ use sqlparser::keywords::Keyword;
use sqlparser::tokenizer::{Token, Tokenizer, Whitespace};
use crate::models::connection::DatabaseType;
-use crate::sql::split_sql_statements_for_database;
+use crate::sql::{oracle_plsql_block_is_complete, split_sql_statements_for_database};
use crate::types::ObjectSourceKind;
mod oracle_routines;
@@ -514,6 +514,18 @@ fn build_executable_object_source_statements_with_mysql_validation_name(
} else {
source
};
+ if matches!(input.database_type, DatabaseType::Oracle | DatabaseType::OceanbaseOracle | DatabaseType::Dameng)
+ && matches!(input.object_type, ObjectSourceKind::Type | ObjectSourceKind::TypeBody)
+ {
+ validate_oracle_object_source(
+ input.database_type,
+ &input.object_type,
+ input.schema.as_deref(),
+ &input.name,
+ source,
+ )?;
+ return Ok(vec![oracle_management_ddl(source, input.schema.as_deref(), &input.object_type)?]);
+ }
if (input.database_type == DatabaseType::Oracle || input.database_type == DatabaseType::OceanbaseOracle)
&& matches!(
input.object_type,
@@ -677,12 +689,30 @@ fn validate_oracle_object_source(
name: &str,
source: &str,
) -> Result<(), String> {
+ let is_type = matches!(object_type, ObjectSourceKind::Type | ObjectSourceKind::TypeBody);
+ let keyword_is = |token: &Token, keyword: &str| {
+ if is_type {
+ unquoted_keyword_is(token, keyword)
+ } else {
+ token_word_is(token, keyword)
+ }
+ };
+ let identifier_is = |token: &Token, expected: &str| {
+ if is_type {
+ matches!(token, Token::Word(word) if if word.quote_style.is_some() { word.value == expected } else { word.value.to_ascii_uppercase() == expected })
+ } else {
+ oracle_identifier_matches(token, expected)
+ }
+ };
let initial_tokens =
Tokenizer::new(&OracleDialect {}, source).tokenize_with_location().map_err(|error| error.to_string())?;
let first_significant = initial_tokens.iter().find(|token| !matches!(token.token, Token::Whitespace(_)));
- let source = if first_significant.is_some_and(|token| token_word_is(&token.token, "CREATE")) {
+ let source = if first_significant.is_some_and(|token| keyword_is(&token.token, "CREATE")) {
source.to_string()
- } else if matches!(object_type, ObjectSourceKind::Procedure | ObjectSourceKind::Function) {
+ } else if matches!(
+ object_type,
+ ObjectSourceKind::Procedure | ObjectSourceKind::Function | ObjectSourceKind::Type | ObjectSourceKind::TypeBody
+ ) {
format!("CREATE OR REPLACE {}", source.trim())
} else {
format!("CREATE {}", source.trim())
@@ -701,19 +731,17 @@ fn validate_oracle_object_source(
.collect::<Vec<_>>();
let token_at = |position: usize| significant.get(position).map(|index| &tokens[*index].token);
let mut position = 0;
- if !token_at(position).is_some_and(|token| token_word_is(token, "CREATE")) {
+ if !token_at(position).is_some_and(|token| keyword_is(token, "CREATE")) {
return Err("Oracle object source must begin with CREATE.".to_string());
}
position += 1;
- if token_at(position).is_some_and(|token| token_word_is(token, "OR")) {
- if !token_at(position + 1).is_some_and(|token| token_word_is(token, "REPLACE")) {
+ if token_at(position).is_some_and(|token| keyword_is(token, "OR")) {
+ if !token_at(position + 1).is_some_and(|token| keyword_is(token, "REPLACE")) {
return Err("Oracle object source has an invalid CREATE prefix.".to_string());
}
position += 2;
}
- if token_at(position)
- .is_some_and(|token| token_word_is(token, "EDITIONABLE") || token_word_is(token, "NONEDITIONABLE"))
- {
+ if token_at(position).is_some_and(|token| keyword_is(token, "EDITIONABLE") || keyword_is(token, "NONEDITIONABLE")) {
position += 1;
}
@@ -728,13 +756,23 @@ fn validate_oracle_object_source(
token_at(position).is_some_and(|token| token_word_is(token, "PACKAGE"))
&& token_at(position + 1).is_some_and(|token| token_word_is(token, "BODY"))
}
+ ObjectSourceKind::Type => {
+ token_at(position).is_some_and(|token| unquoted_keyword_is(token, "TYPE"))
+ && !token_at(position + 1).is_some_and(|token| unquoted_keyword_is(token, "BODY"))
+ }
+ ObjectSourceKind::TypeBody => {
+ token_at(position).is_some_and(|token| unquoted_keyword_is(token, "TYPE"))
+ && token_at(position + 1).is_some_and(|token| unquoted_keyword_is(token, "BODY"))
+ }
+ ObjectSourceKind::View => token_at(position).is_some_and(|token| unquoted_keyword_is(token, "VIEW")),
+ ObjectSourceKind::Trigger => token_at(position).is_some_and(|token| unquoted_keyword_is(token, "TRIGGER")),
_ => false,
};
if !kind_matches {
return Err(format!("Oracle object source declaration does not match {object_type:?}."));
}
position += 1;
- if *object_type == ObjectSourceKind::PackageBody {
+ if *object_type == ObjectSourceKind::PackageBody || *object_type == ObjectSourceKind::TypeBody {
position += 1;
}
@@ -746,11 +784,11 @@ fn validate_oracle_object_source(
} else {
(None, first_name, 1)
};
- if !oracle_identifier_matches(declared_name, name) {
+ if !identifier_is(declared_name, name) {
return Err(format!("Oracle source declares a different object than {name}."));
}
if let Some(Token::Word(owner)) = owner {
- if schema.is_some_and(|schema| !oracle_identifier_matches(&Token::Word(owner.clone()), schema)) {
+ if schema.is_some_and(|schema| !identifier_is(&Token::Word(owner.clone()), schema)) {
return Err("Oracle object source owner does not match the selected schema.".to_string());
}
} else if owner.is_some() {
@@ -759,13 +797,228 @@ fn validate_oracle_object_source(
if token_at(position + consumed).is_some_and(|token| token == &Token::Period) {
return Err("Three-part Oracle object names are not supported.".to_string());
}
+ if matches!(object_type, ObjectSourceKind::Type | ObjectSourceKind::TypeBody)
+ && significant.iter().enumerate().any(|(index, token_index)| {
+ unquoted_keyword_is(&tokens[*token_index].token, "FORCE")
+ && significant[..index].iter().all(|earlier| {
+ !unquoted_keyword_is(&tokens[*earlier].token, "AS")
+ && !unquoted_keyword_is(&tokens[*earlier].token, "IS")
+ })
+ })
+ {
+ return Err("FORCE is not supported when editing an Oracle-family type.".to_string());
+ }
+ if matches!(object_type, ObjectSourceKind::Type | ObjectSourceKind::TypeBody) {
+ let mut brackets = Vec::new();
+ for index in &significant {
+ match &tokens[*index].token {
+ Token::LParen => brackets.push(Token::RParen),
+ Token::LBracket => brackets.push(Token::RBracket),
+ Token::RParen | Token::RBracket if brackets.pop().as_ref() != Some(&tokens[*index].token) => {
+ return Err("TYPE source contains an unmatched closing bracket.".into());
+ }
+ _ => {}
+ }
+ }
+ if !brackets.is_empty() {
+ return Err("TYPE source contains an incomplete declaration.".into());
+ }
+ if !significant[position + consumed..].iter().any(|index| {
+ ["AS", "IS", "UNDER"].iter().any(|keyword| unquoted_keyword_is(&tokens[*index].token, keyword))
+ }) {
+ return Err("TYPE source has no complete definition after its name.".into());
+ }
+ if *object_type == ObjectSourceKind::TypeBody && !oracle_plsql_block_is_complete(&source) {
+ return Err("TYPE BODY source is missing its outer END or contains an incomplete block.".into());
+ }
+ }
Ok(())
}
+fn oracle_management_ddl(source: &str, schema: Option<&str>, object_type: &ObjectSourceKind) -> Result<String, String> {
+ let mut source = strip_standalone_trailing_slash(source).to_string();
+ let tokenize = |source: &str| {
+ Tokenizer::new(&OracleDialect {}, source)
+ .tokenize_with_location()
+ .map(|tokens| {
+ tokens.into_iter().filter(|token| !matches!(token.token, Token::Whitespace(_))).collect::<Vec<_>>()
+ })
+ .map_err(|error| error.to_string())
+ };
+ let tokens = tokenize(&source)?;
+ let first = tokens.first().ok_or_else(|| "TYPE source is empty.".to_string())?;
+ if unquoted_keyword_is(&first.token, "CREATE") {
+ if !tokens.get(1).is_some_and(|token| unquoted_keyword_is(&token.token, "OR")) {
+ let offset =
+ routine_location_to_byte_offset(&source, first.span.end).ok_or("Cannot locate TYPE CREATE prefix")?;
+ source.insert_str(offset, " OR REPLACE");
+ }
+ } else {
+ let offset =
+ routine_location_to_byte_offset(&source, first.span.start).ok_or("Cannot locate TYPE declaration")?;
+ source.insert_str(offset, "CREATE OR REPLACE ");
+ }
+ if let Some(owner) = schema.filter(|owner| !owner.is_empty()) {
+ let tokens = tokenize(&source)?;
+ let keyword = match object_type {
+ ObjectSourceKind::Type | ObjectSourceKind::TypeBody => "TYPE",
+ ObjectSourceKind::Package | ObjectSourceKind::PackageBody => "PACKAGE",
+ ObjectSourceKind::Procedure => "PROCEDURE",
+ ObjectSourceKind::Function => "FUNCTION",
+ ObjectSourceKind::View => "VIEW",
+ ObjectSourceKind::Trigger => "TRIGGER",
+ _ => return Err("This object cannot be rebuilt by the TYPE manager.".into()),
+ };
+ let type_index = tokens
+ .iter()
+ .position(|token| unquoted_keyword_is(&token.token, keyword))
+ .ok_or("Cannot locate the object declaration keyword")?;
+ let name_index = type_index
+ + if matches!(object_type, ObjectSourceKind::TypeBody | ObjectSourceKind::PackageBody) { 2 } else { 1 };
+ if tokens.get(name_index + 1).is_none_or(|token| token.token != Token::Period) {
+ let token = tokens.get(name_index).ok_or("TYPE declaration has no name")?;
+ let offset = routine_location_to_byte_offset(&source, token.span.start).ok_or("Cannot locate TYPE name")?;
+ source.insert_str(offset, &format!("\"{}\".", owner.replace('"', "\"\"")));
+ }
+ }
+ Ok(ensure_semicolon(&source))
+}
+
+/// Build a source-backed step and its comparison value for TYPE management.
+/// This deliberately does not change the ordinary object-source save contract.
+pub fn build_oracle_type_management_source(input: EditableObjectSourceSqlInput) -> Result<(String, String), String> {
+ if !matches!(input.database_type, DatabaseType::Oracle | DatabaseType::OceanbaseOracle | DatabaseType::Dameng)
+ || !matches!(
+ input.object_type,
+ ObjectSourceKind::Type
+ | ObjectSourceKind::TypeBody
+ | ObjectSourceKind::Procedure
+ | ObjectSourceKind::Function
+ | ObjectSourceKind::Package
+ | ObjectSourceKind::PackageBody
+ | ObjectSourceKind::View
+ | ObjectSourceKind::Trigger
+ )
+ {
+ return Err("TYPE management supports only Oracle-family source-backed dependencies.".into());
+ }
+ validate_oracle_object_source(
+ input.database_type,
+ &input.object_type,
+ input.schema.as_deref(),
+ &input.name,
+ &input.source,
+ )?;
+ let sql = oracle_management_ddl(&input.source, input.schema.as_deref(), &input.object_type)?;
+ let tokens = Tokenizer::new(&OracleDialect {}, &sql).tokenize().map_err(|error| error.to_string())?;
+ let significant = tokens
+ .iter()
+ .enumerate()
+ .filter_map(|(index, token)| (!matches!(token, Token::Whitespace(_))).then_some(index))
+ .collect::<Vec<_>>();
+ let keyword = match input.object_type {
+ ObjectSourceKind::Type | ObjectSourceKind::TypeBody => "TYPE",
+ ObjectSourceKind::Package | ObjectSourceKind::PackageBody => "PACKAGE",
+ ObjectSourceKind::Procedure => "PROCEDURE",
+ ObjectSourceKind::Function => "FUNCTION",
+ ObjectSourceKind::View => "VIEW",
+ ObjectSourceKind::Trigger => "TRIGGER",
+ _ => unreachable!(),
+ };
+ let kind_position = significant
+ .iter()
+ .position(|index| unquoted_keyword_is(&tokens[*index], keyword))
+ .ok_or("Missing management declaration")?;
+ let first_name = kind_position
+ + if matches!(input.object_type, ObjectSourceKind::TypeBody | ObjectSourceKind::PackageBody) { 2 } else { 1 };
+ let qualified = significant.get(first_name + 1).is_some_and(|index| tokens[*index] == Token::Period);
+ let name_index =
+ *significant.get(first_name + if qualified { 2 } else { 0 }).ok_or("Missing management object name")?;
+ let owner_index = qualified.then(|| significant[first_name]);
+ let fingerprint = tokens
+ .into_iter()
+ .enumerate()
+ .filter_map(|(index, token)| {
+ if index == name_index {
+ Some(format!("target-name:{}", input.name))
+ } else if Some(index) == owner_index {
+ let owner = input.schema.clone().unwrap_or_else(|| match &token {
+ Token::Word(word) if word.quote_style.is_none() => word.value.to_ascii_uppercase(),
+ Token::Word(word) => word.value.clone(),
+ _ => token.to_string(),
+ });
+ Some(format!("target-owner:{owner}"))
+ } else {
+ match token {
+ Token::Whitespace(Whitespace::Space | Whitespace::Tab | Whitespace::Newline) | Token::EOF => None,
+ Token::Word(word) if word.quote_style.is_none() => {
+ Some(format!("word:{}", word.value.to_ascii_uppercase()))
+ }
+ token => Some(format!("token:{token}")),
+ }
+ }
+ })
+ .collect::<Vec<_>>();
+ let fingerprint = serde_json::to_string(&fingerprint).map_err(|error| error.to_string())?;
+ Ok((sql, fingerprint))
+}
+
+/// Rebuild directly in the original firing state, never ENABLE then DISABLE.
+pub fn build_oracle_type_management_trigger_source(
+ mut input: EditableObjectSourceSqlInput,
+ enabled: bool,
+) -> Result<(String, String), String> {
+ if input.object_type != ObjectSourceKind::Trigger {
+ return Err("A trigger firing state applies only to a TRIGGER definition.".into());
+ }
+ let (mut sql, fingerprint) = build_oracle_type_management_source(input.clone())?;
+ if input.database_type == DatabaseType::Dameng {
+ return if enabled {
+ Ok((sql, fingerprint))
+ } else {
+ Err("DM cannot yet rebuild a disabled trigger without a verified disabled-at-create syntax. Keep its definition unchanged for COMPILE, or prepare that dependency separately before starting this TYPE plan.".into())
+ };
+ }
+ let tokens = Tokenizer::new(&OracleDialect {}, &sql).tokenize_with_location().map_err(|e| e.to_string())?;
+ let tokens: Vec<_> = tokens.iter().filter(|t| !matches!(t.token, Token::Whitespace(_))).collect();
+ let declaration =
+ tokens.iter().position(|t| unquoted_keyword_is(&t.token, "TRIGGER")).ok_or("Missing TRIGGER declaration")?;
+ let name = declaration + 1;
+ let after_name = name + if tokens.get(name + 1).is_some_and(|t| t.token == Token::Period) { 3 } else { 1 };
+ let body = tokens
+ .iter()
+ .enumerate()
+ .skip(after_name)
+ .find(|(_, t)| {
+ ["WHEN", "DECLARE", "BEGIN", "CALL", "COMPOUND"].iter().any(|word| unquoted_keyword_is(&t.token, word))
+ })
+ .map(|(i, _)| i)
+ .ok_or(
+ "Cannot locate a supported trigger body or WHEN clause; keep the draft and prepare this trigger separately",
+ )?;
+ let state = if enabled { "ENABLE" } else { "DISABLE" };
+ let previous =
+ tokens.get(body - 1).filter(|t| ["ENABLE", "DISABLE"].iter().any(|word| unquoted_keyword_is(&t.token, word)));
+ let (start, end, replacement) = if let Some(previous) = previous {
+ (previous.span.start, previous.span.end, state.to_string())
+ } else {
+ (tokens[body].span.start, tokens[body].span.start, format!("{state} "))
+ };
+ let start = routine_location_to_byte_offset(&sql, start).ok_or("Cannot locate the trigger state")?;
+ let end = routine_location_to_byte_offset(&sql, end).ok_or("Cannot locate the trigger state")?;
+ sql.replace_range(start..end, &replacement);
+ input.source = sql;
+ build_oracle_type_management_source(input)
+}
+
fn oracle_identifier_matches(token: &Token, expected: &str) -> bool {
matches!(token, Token::Word(word) if identifier_matches(word, expected))
}
+fn unquoted_keyword_is(token: &Token, expected: &str) -> bool {
+ matches!(token, Token::Word(word) if word.quote_style.is_none() && word.value.eq_ignore_ascii_case(expected))
+}
+
/// Convert a raw database object source into a form suitable for the source editor.
///
/// This is the *editable* presentation shown to the user when they open a view,
@@ -1995,6 +2248,278 @@ mod tests {
}
}
+ fn type_management_source(
+ database_type: DatabaseType,
+ object_type: ObjectSourceKind,
+ name: &str,
+ source: &str,
+ ) -> EditableObjectSourceSqlInput {
+ EditableObjectSourceSqlInput {
+ database_type,
+ object_type,
+ schema: Some("Exact Owner".to_string()),
+ name: name.to_string(),
+ source: source.to_string(),
+ }
+ }
+
+ #[test]
+ fn oracle_family_type_management_accepts_one_exact_type_or_body_definition() {
+ let type_source = "CREATE OR REPLACE TYPE \"Exact Owner\".\"Address Type\" AS OBJECT (id NUMBER);";
+ let body_source = "CREATE OR REPLACE TYPE BODY \"Exact Owner\".\"Address Type\" AS MEMBER FUNCTION score RETURN NUMBER IS BEGIN RETURN 1; END; END;\n/";
+ for database_type in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle, DatabaseType::Dameng] {
+ for (object_type, source) in
+ [(ObjectSourceKind::Type, type_source), (ObjectSourceKind::TypeBody, body_source)]
+ {
+ let statements = build_executable_object_source_statements(type_management_source(
+ database_type,
+ object_type.clone(),
+ "Address Type",
+ source,
+ ))
+ .unwrap();
+ assert_eq!(statements.len(), 1, "{database_type:?} {object_type:?}");
+ assert!(statements[0].contains("Address Type"));
+ }
+ }
+ }
+
+ #[test]
+ fn oracle_family_type_management_rejects_wrong_name_kind_and_extra_ddl() {
+ for database_type in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle, DatabaseType::Dameng] {
+ for (object_type, name, source) in [
+ (
+ ObjectSourceKind::Type,
+ "Address Type",
+ "CREATE TYPE \"Exact Owner\".\"Other Type\" AS OBJECT (id NUMBER);",
+ ),
+ (ObjectSourceKind::Type, "Address Type", "CREATE TYPE BODY \"Exact Owner\".\"Address Type\" AS END;"),
+ (
+ ObjectSourceKind::TypeBody,
+ "Address Type",
+ "CREATE TYPE \"Exact Owner\".\"Address Type\" AS OBJECT (id NUMBER);",
+ ),
+ (
+ ObjectSourceKind::Type,
+ "Address Type",
+ "CREATE TYPE \"Exact Owner\".\"Address Type\" AS OBJECT (id NUMBER); DROP TABLE \"Exact Owner\".T;",
+ ),
+ (
+ ObjectSourceKind::Type,
+ "Address Type",
+ "CREATE TYPE \"Other Owner\".\"Address Type\" AS OBJECT (id NUMBER);",
+ ),
+ ] {
+ assert!(
+ build_executable_object_source_statements(type_management_source(
+ database_type,
+ object_type.clone(),
+ name,
+ source
+ ))
+ .is_err(),
+ "accepted {database_type:?} {object_type:?}: {source}"
+ );
+ }
+ }
+ }
+
+ #[test]
+ fn oracle_family_type_management_requires_complete_blocks_and_rejects_getddl_mixtures() {
+ for database_type in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle, DatabaseType::Dameng] {
+ for (kind, source) in [
+ (ObjectSourceKind::Type, "CREATE TYPE \"Exact Owner\".\"Address Type\" AS OBJECT (ID NUMBER"),
+ (ObjectSourceKind::TypeBody, "CREATE TYPE BODY \"Exact Owner\".\"Address Type\" AS MEMBER FUNCTION F RETURN NUMBER IS BEGIN RETURN 1; END;"),
+ (ObjectSourceKind::Type, "CREATE TYPE \"Exact Owner\".\"Address Type\" AS OBJECT(ID NUMBER); CREATE TYPE BODY \"Exact Owner\".\"Address Type\" AS MEMBER FUNCTION F RETURN NUMBER IS BEGIN RETURN 1; END; END;"),
+ (ObjectSourceKind::Type, "CREATE TYPE \"Exact Owner\".\"Address Type\" FORCE AS OBJECT(ID NUMBER);"),
+ ] {
+ assert!(build_executable_object_source_statements(type_management_source(database_type, kind.clone(), "Address Type", source)).is_err(), "accepted {database_type:?} {kind:?}: {source}");
+ }
+ }
+ }
+
+ #[test]
+ fn oracle_family_type_management_qualifies_dictionary_source_and_preserves_comments_and_literals() {
+ for database_type in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle, DatabaseType::Dameng] {
+ for source in [
+ "-- source header\nTYPE \"Address Type\" AS OBJECT(ID NUMBER)",
+ "CREATE /* retained */ TYPE \"Address Type\" AS OBJECT(ID NUMBER)",
+ "TYPE BODY \"Address Type\" AS MEMBER FUNCTION F RETURN NUMBER IS V VARCHAR2(80):=q'[END; DROP TABLE literal_only;]'; BEGIN IF 1=1 THEN RETURN 1; END IF; RETURN 0; END; END;\n/",
+ ] {
+ let kind = if source.contains("TYPE BODY") { ObjectSourceKind::TypeBody } else { ObjectSourceKind::Type };
+ let sql = build_executable_object_source_statements(type_management_source(database_type, kind, "Address Type", source)).unwrap().join("\n");
+ assert!(sql.contains("\"Exact Owner\".\"Address Type\""), "target owner not bound: {sql}");
+ if source.contains("retained") { assert!(sql.contains("/* retained */")); }
+ if source.contains("literal_only") { assert!(sql.contains("q'[END; DROP TABLE literal_only;]'")); }
+ }
+ }
+ }
+
+ #[test]
+ fn oracle_family_type_management_accepts_vendor_forms_and_quoted_keyword_names() {
+ for database_type in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle, DatabaseType::Dameng] {
+ for name in ["BODY", "FORCE", "TYPE"] {
+ for qualifier in ["\"Exact Owner\".", ""] {
+ let source = format!("CREATE TYPE {qualifier}\"{name}\" AS OBJECT(ID NUMBER);");
+ assert!(
+ build_executable_object_source_statements(type_management_source(
+ database_type,
+ ObjectSourceKind::Type,
+ name,
+ &source
+ ))
+ .is_ok(),
+ "rejected quoted {name} for {database_type:?}"
+ );
+ }
+ }
+ }
+ for source in [
+ "TYPE \"Address Type\" IS RECORD (ID NUMBER, LABEL VARCHAR(40));",
+ "TYPE \"Address Type\" IS ARRAY INTEGER[3];",
+ "TYPE \"Address Type\" AS TABLE OF NUMBER INDEX BY VARCHAR(40);",
+ "TYPE \"Address Type\" AS VARRAY(20) OF NUMBER;",
+ "TYPE \"Address Type\" UNDER \"Parent Type\" (LABEL VARCHAR(40)) NOT FINAL;",
+ ] {
+ assert!(
+ build_executable_object_source_statements(type_management_source(
+ DatabaseType::Dameng,
+ ObjectSourceKind::Type,
+ "Address Type",
+ source
+ ))
+ .is_ok(),
+ "rejected DM type form: {source}"
+ );
+ }
+ }
+
+ #[test]
+ fn oracle_family_type_management_quoted_keywords_do_not_hide_force() {
+ for database_type in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle, DatabaseType::Dameng] {
+ let source = "CREATE OR REPLACE TYPE \"Exact Owner\".\"AS\" FORCE AS OBJECT(ID NUMBER);";
+ assert!(
+ build_executable_object_source_statements(type_management_source(
+ database_type,
+ ObjectSourceKind::Type,
+ "AS",
+ source
+ ))
+ .is_err(),
+ "quoted AS name bypassed FORCE rejection for {database_type:?}"
+ );
+ }
+ }
+
+ #[test]
+ fn type_management_trigger_rebuild_has_the_requested_state_in_the_create_statement() {
+ for database_type in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle] {
+ for header in [
+ "BEFORE INSERT ON APP.T FOR EACH ROW",
+ "BEFORE INSERT ON APP.T FOR EACH ROW ENABLE WHEN (NEW.ID > 0)",
+ "FOR INSERT ON APP.T",
+ ] {
+ for enabled in [false, true] {
+ let body = if header.starts_with("FOR ") {
+ "COMPOUND TRIGGER BEFORE STATEMENT IS BEGIN NULL; END BEFORE STATEMENT; END;"
+ } else {
+ "BEGIN NULL; END;"
+ };
+ let input = type_management_source(
+ database_type,
+ ObjectSourceKind::Trigger,
+ "Address Type",
+ &format!("TRIGGER \"Address Type\" {header} {body}"),
+ );
+ let (sql, expected) = build_oracle_type_management_trigger_source(input.clone(), enabled).unwrap();
+ let state = if enabled { "ENABLE" } else { "DISABLE" };
+ assert!(
+ sql.contains(&format!("{state} WHEN"))
+ || sql.contains(&format!("{state} BEGIN"))
+ || sql.contains(&format!("{state} COMPOUND")),
+ "{sql}"
+ );
+ assert_eq!(split_sql_statements_for_database(&sql, database_type).len(), 1);
+ assert_eq!(
+ build_oracle_type_management_source(EditableObjectSourceSqlInput { source: sql, ..input })
+ .unwrap()
+ .1,
+ expected
+ );
+ }
+ }
+ }
+ let input = type_management_source(
+ DatabaseType::Dameng,
+ ObjectSourceKind::Trigger,
+ "Address Type",
+ "TRIGGER \"Address Type\" BEFORE INSERT ON APP.T BEGIN NULL; END;",
+ );
+ assert!(build_oracle_type_management_trigger_source(input.clone(), false).is_err());
+ assert!(build_oracle_type_management_trigger_source(input, true).is_ok());
+ }
+
+ #[test]
+ fn type_management_dependency_builder_binds_callers_and_compares_normalized_source() {
+ for database_type in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle, DatabaseType::Dameng] {
+ for (kind, source) in [
+ (ObjectSourceKind::Procedure, "PROCEDURE \"Address Type\" AS BEGIN NULL; END;"),
+ (ObjectSourceKind::Function, "FUNCTION \"Address Type\" RETURN NUMBER AS BEGIN RETURN 1; END;"),
+ (ObjectSourceKind::View, "CREATE VIEW \"Address Type\" AS SELECT 1 AS ID FROM DUAL;"),
+ (ObjectSourceKind::Trigger, "CREATE TRIGGER \"Address Type\" BEFORE INSERT ON T BEGIN NULL; END;"),
+ (ObjectSourceKind::Package, "CREATE PACKAGE \"Address Type\" AS PROCEDURE P; END;"),
+ (
+ ObjectSourceKind::PackageBody,
+ "CREATE PACKAGE BODY \"Address Type\" AS PROCEDURE P IS BEGIN NULL; END; END;",
+ ),
+ ] {
+ let input = type_management_source(database_type, kind.clone(), "Address Type", source);
+ let (sql, fingerprint) = build_oracle_type_management_source(input.clone()).unwrap();
+ assert!(sql.contains("\"Exact Owner\".\"Address Type\""));
+ let (_, readback) =
+ build_oracle_type_management_source(EditableObjectSourceSqlInput { source: sql, ..input }).unwrap();
+ assert_eq!(fingerprint, readback);
+ let input = type_management_source(database_type, kind, "Different Type", source);
+ assert!(build_oracle_type_management_source(input).is_err());
+ }
+ }
+ let (first, second) = (
+ "procedure \"Address Type\" as begin null; end;",
+ "CREATE OR REPLACE PROCEDURE \"Exact Owner\".\"Address Type\" AS BEGIN NULL; END;",
+ );
+ let make = |source| {
+ build_oracle_type_management_source(type_management_source(
+ DatabaseType::Oracle,
+ ObjectSourceKind::Procedure,
+ "Address Type",
+ source,
+ ))
+ .unwrap()
+ .1
+ };
+ assert_eq!(make(first), make(second));
+ assert_ne!(make(second), make("CREATE PROCEDURE \"Address Type\" AS BEGIN NULL; /* preserved */ END;"));
+ }
+
+ #[test]
+ fn type_management_readback_compares_the_validated_target_not_catalogue_quoting() {
+ let make = |source: &str| {
+ build_oracle_type_management_source(EditableObjectSourceSqlInput {
+ database_type: DatabaseType::OceanbaseOracle,
+ object_type: ObjectSourceKind::Type,
+ schema: Some("APP".into()),
+ name: "ROOT".into(),
+ source: source.into(),
+ })
+ .map(|(_, fingerprint)| fingerprint)
+ };
+ let expected = make("CREATE OR REPLACE TYPE APP.ROOT AS OBJECT (ID NUMBER);").unwrap();
+ assert_eq!(expected, make("TYPE ROOT AS OBJECT (ID NUMBER);").unwrap());
+ assert_eq!(expected, make("CREATE TYPE \"APP\".\"ROOT\" AS OBJECT (ID NUMBER);").unwrap());
+ assert!(make("\"CREATE\" TYPE APP.ROOT AS OBJECT (ID NUMBER);").is_err());
+ assert!(make("CREATE \"OR\" REPLACE TYPE APP.ROOT AS OBJECT (ID NUMBER);").is_err());
+ }
+
fn ob_sequence(source: &str, schema: Option<&str>, name: &str) -> EditableObjectSourceSqlInput {
EditableObjectSourceSqlInput {
database_type: DatabaseType::OceanbaseOracle,
diff --git a/crates/dbx-sql-core/src/oracle_type_migration_sql.rs b/crates/dbx-sql-core/src/oracle_type_migration_sql.rs
new file mode 100644
index 0000000000..3221b435e1
--- /dev/null
+++ b/crates/dbx-sql-core/src/oracle_type_migration_sql.rs
@@ -0,0 +1,976 @@
+//! Bounded TYPE migration syntax. Every token belongs to the accepted grammar;
+//! arbitrary SQL remains in the ordinary SQL editor, not in a migration plan.
+use sqlparser::dialect::OracleDialect;
+use sqlparser::tokenizer::{Token, Tokenizer, Whitespace};
+
+fn quote(value: &str) -> String {
+ format!("\"{}\"", value.replace('"', "\"\""))
+}
+
+#[derive(Clone)]
+struct Cursor {
+ tokens: Vec<Token>,
+ at: usize,
+}
+impl Cursor {
+ fn new(sql: &str) -> Result<Self, String> {
+ let mut tokens = Vec::new();
+ for token in Tokenizer::new(&OracleDialect {}, sql).tokenize().map_err(|e| e.to_string())? {
+ match token {
+ Token::Whitespace(Whitespace::Space | Whitespace::Newline | Whitespace::Tab) => (),
+ Token::Whitespace(_) => {
+ return Err("Comments and hints are not part of the bounded migration grammar".into())
+ }
+ other => tokens.push(other),
+ }
+ }
+ Ok(Self { tokens, at: 0 })
+ }
+ fn keyword(&mut self, word: &str) -> bool {
+ if matches!(self.tokens.get(self.at), Some(Token::Word(w)) if w.quote_style.is_none() && w.value.eq_ignore_ascii_case(word))
+ {
+ self.at += 1;
+ true
+ } else {
+ false
+ }
+ }
+ fn expect_keyword(&mut self, word: &str) -> Result<(), String> {
+ if self.keyword(word) {
+ Ok(())
+ } else {
+ Err(format!("Expected {word} in the bounded migration statement"))
+ }
+ }
+ fn take(&mut self, token: Token) -> bool {
+ if self.tokens.get(self.at) == Some(&token) {
+ self.at += 1;
+ true
+ } else {
+ false
+ }
+ }
+ fn expect(&mut self, token: Token) -> Result<(), String> {
+ if self.take(token.clone()) {
+ Ok(())
+ } else {
+ Err(format!("Expected {token} in the bounded migration statement"))
+ }
+ }
+ fn ident(&mut self) -> Result<String, String> {
+ match self.tokens.get(self.at) {
+ Some(Token::Word(word)) if word.quote_style.is_none() || word.quote_style == Some('"') => {
+ let value = if word.quote_style.is_some() { word.value.clone() } else { word.value.to_uppercase() };
+ self.at += 1;
+ if value.is_empty() {
+ Err("Empty identifier".into())
+ } else {
+ Ok(value)
+ }
+ }
+ _ => Err("Expected an exact column or relation identifier".into()),
+ }
+ }
+ fn number(&mut self) -> Result<i32, String> {
+ let negative = self.take(Token::Minus);
+ match self.tokens.get(self.at) {
+ Some(Token::Number(value, false)) if value.bytes().all(|c| c.is_ascii_digit()) => {
+ let value = value.parse::<i32>().map_err(|_| "Numeric type dimension exceeds the supported range")?;
+ self.at += 1;
+ Ok(if negative { -value } else { value })
+ }
+ _ => Err("Expected an integer type dimension".into()),
+ }
+ }
+ fn relation(&mut self) -> Result<(String, String), String> {
+ let owner = self.ident()?;
+ self.expect(Token::Period)?;
+ Ok((owner, self.ident()?))
+ }
+ fn end(&mut self) -> Result<(), String> {
+ self.take(Token::SemiColon);
+ if self.at == self.tokens.len() {
+ Ok(())
+ } else {
+ Err("The complete statement contains unsupported syntax or an additional statement".into())
+ }
+ }
+}
+
+fn oceanbase_table_header(owner: &str, name: &str, ddl: &str) -> Result<Cursor, String> {
+ let mut cursor = Cursor::new(ddl)?;
+ cursor.expect_keyword("CREATE")?;
+ cursor.expect_keyword("TABLE")?;
+ let first = cursor.ident()?;
+ let identity_matches =
+ if cursor.take(Token::Period) { first == owner && cursor.ident()? == name } else { first == name };
+ if !identity_matches {
+ return Err("The native table definition does not match the exact requested relation".into());
+ }
+ cursor.expect(Token::LParen)?;
+ Ok(cursor)
+}
+
+/// OceanBase can return NULL for ALL_TABLES.READ_ONLY even after ALTER TABLE
+/// READ ONLY. Only its complete, exact native simple-table definition supplies
+/// the fallback; an unfamiliar or partial suffix must remain unverifiable.
+pub fn oceanbase_table_read_only_from_ddl(owner: &str, name: &str, ddl: &str) -> Result<bool, String> {
+ let mut cursor = oceanbase_table_header(owner, name, ddl)?;
+ let start = cursor.at;
+ let mut depth = 1;
+ while depth > 0 {
+ match cursor.tokens.get(cursor.at) {
+ Some(Token::LParen) => depth += 1,
+ Some(Token::RParen) => depth -= 1,
+ None | Some(Token::SemiColon) => return Err("The native table definition is incomplete".into()),
+ _ => (),
+ }
+ cursor.at += 1;
+ }
+ if cursor.at == start + 1 {
+ return Err("The native table definition has no columns".into());
+ }
+ let mut options = std::collections::HashSet::new();
+ loop {
+ if cursor.keyword("COMPRESS") {
+ if !options.insert("COMPRESS") {
+ return Err("Duplicate native table option".into());
+ }
+ cursor.expect_keyword("FOR")?;
+ cursor.expect_keyword("ARCHIVE")?;
+ } else if cursor.keyword("USE_BLOOM_FILTER") {
+ if !options.insert("USE_BLOOM_FILTER") {
+ return Err("Duplicate native table option".into());
+ }
+ cursor.expect(Token::Eq)?;
+ if !cursor.keyword("TRUE") && !cursor.keyword("FALSE") {
+ return Err("Unknown native bloom-filter state".into());
+ }
+ } else if let Some(option) =
+ ["REPLICA_NUM", "BLOCK_SIZE", "TABLET_SIZE", "PCTFREE"].into_iter().find(|option| cursor.keyword(option))
+ {
+ if !options.insert(option) {
+ return Err("Duplicate native table option".into());
+ }
+ cursor.expect(Token::Eq)?;
+ if cursor.number()? < 0 {
+ return Err("Invalid native table option".into());
+ }
+ } else {
+ break;
+ }
+ }
+ if options.len() != 6 {
+ return Err("The complete supported OceanBase native table suffix is required".into());
+ }
+ let read_only = if cursor.keyword("READ") {
+ if cursor.keyword("ONLY") {
+ true
+ } else {
+ cursor.expect_keyword("WRITE")?;
+ false
+ }
+ } else {
+ false
+ };
+ cursor.end()?;
+ Ok(read_only)
+}
+
+/// Prove the native INSERT target has only explicit scalar columns and simple
+/// keys. In particular, NULL compatibility flags cannot hide a default, identity
+/// or generated expression. Unfamiliar definitions need external preparation.
+pub fn oceanbase_scalar_insert_columns(owner: &str, name: &str, ddl: &str) -> Result<Vec<String>, String> {
+ if oceanbase_table_read_only_from_ddl(owner, name, ddl)? {
+ return Err("The native scalar INSERT target must be READ WRITE".into());
+ }
+ let mut cursor = oceanbase_table_header(owner, name, ddl)?;
+ let mut columns = Vec::new();
+ let mut keys = Vec::new();
+ loop {
+ let named_constraint = cursor.keyword("CONSTRAINT");
+ if named_constraint {
+ cursor.ident()?;
+ }
+ let primary = cursor.keyword("PRIMARY");
+ if primary || cursor.keyword("UNIQUE") {
+ if primary {
+ cursor.expect_keyword("KEY")?;
+ }
+ cursor.expect(Token::LParen)?;
+ let mut key = vec![cursor.ident()?];
+ while cursor.take(Token::Comma) {
+ key.push(cursor.ident()?);
+ }
+ cursor.expect(Token::RParen)?;
+ keys.push(key);
+ } else if named_constraint {
+ return Err("Only simple PRIMARY/UNIQUE constraints are supported in the native INSERT definition".into());
+ } else {
+ let column = cursor.ident()?;
+ ScalarType::read(&mut cursor)?;
+ if cursor.keyword("NOT") {
+ cursor.expect_keyword("NULL")?;
+ } else {
+ cursor.keyword("NULL");
+ }
+ if columns.contains(&column) {
+ return Err("Duplicate native scalar column".into());
+ }
+ columns.push(column);
+ }
+ if !cursor.take(Token::Comma) {
+ cursor.expect(Token::RParen)?;
+ break;
+ }
+ }
+ if columns.is_empty()
+ || keys.iter().any(|key| {
+ key.iter().any(|column| !columns.contains(column))
+ || key.iter().collect::<std::collections::HashSet<_>>().len() != key.len()
+ })
+ {
+ return Err("The complete native scalar columns and key references could not be verified".into());
+ }
+ Ok(columns)
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ScalarType {
+ pub name: String,
+ pub size: Option<i32>,
+ pub scale: Option<i32>,
+ pub semantics: Option<String>,
+}
+impl ScalarType {
+ pub fn parse(sql: &str) -> Result<Self, String> {
+ let mut cursor = Cursor::new(sql)?;
+ let value = Self::read(&mut cursor)?;
+ cursor.end()?;
+ Ok(value)
+ }
+ fn read(cursor: &mut Cursor) -> Result<Self, String> {
+ if !matches!(cursor.tokens.get(cursor.at), Some(Token::Word(word)) if word.quote_style.is_none()) {
+ return Err("A bounded scalar type must be an unquoted built-in type, not a user-defined type".into());
+ }
+ let name = cursor.ident()?;
+ if !["NUMBER", "VARCHAR2", "NVARCHAR2", "CHAR", "NCHAR", "RAW", "DATE", "TIMESTAMP"].contains(&name.as_str()) {
+ return Err(format!("{name} needs a verified scalar projection in the SQL editor"));
+ }
+ let mut value = Self { name, size: None, scale: None, semantics: None };
+ if cursor.take(Token::LParen) {
+ value.size = Some(cursor.number()?);
+ if cursor.take(Token::Comma) {
+ value.scale = Some(cursor.number()?);
+ }
+ if cursor.keyword("BYTE") {
+ value.semantics = Some("BYTE".into());
+ } else if cursor.keyword("CHAR") {
+ value.semantics = Some("CHAR".into());
+ }
+ cursor.expect(Token::RParen)?;
+ }
+ match value.name.as_str() {
+ "NUMBER" => {
+ if value.size.is_some_and(|p| !(1..=38).contains(&p))
+ || value.scale.is_some_and(|s| !(-84..=127).contains(&s))
+ || value.semantics.is_some()
+ {
+ return Err("Unsupported NUMBER precision or scale".into());
+ }
+ if value.size.is_some() {
+ value.scale = Some(value.scale.unwrap_or(0));
+ }
+ }
+ "DATE" if value.size.is_none() => (),
+ "TIMESTAMP"
+ if value.size.is_none_or(|p| (0..=9).contains(&p))
+ && value.scale.is_none()
+ && value.semantics.is_none() =>
+ {
+ value.size = Some(value.size.unwrap_or(6));
+ }
+ "CHAR" | "VARCHAR2" | "RAW" | "NCHAR" | "NVARCHAR2"
+ if value.size.is_some_and(|n| n > 0 && n <= 32767) && value.scale.is_none() =>
+ {
+ if matches!(value.name.as_str(), "NCHAR" | "NVARCHAR2") {
+ value.semantics = Some("CHAR".into());
+ }
+ if value.name == "RAW" && value.semantics.is_some() {
+ return Err("RAW has no character semantics".into());
+ }
+ }
+ _ => return Err("Unsupported scalar type dimensions".into()),
+ }
+ Ok(value)
+ }
+ pub fn sql(&self) -> String {
+ match self.name.as_str() {
+ "NUMBER" => {
+ self.size.map(|p| format!("NUMBER({p},{})", self.scale.unwrap_or(0))).unwrap_or_else(|| "NUMBER".into())
+ }
+ "DATE" => "DATE".into(),
+ "TIMESTAMP" => format!("TIMESTAMP({})", self.size.unwrap_or(6)),
+ _ => format!(
+ "{}({}{})",
+ self.name,
+ self.size.unwrap_or(0),
+ self.semantics.as_ref().map(|s| format!(" {s}")).unwrap_or_default()
+ ),
+ }
+ }
+ pub fn losslessly_accepts(&self, old: &Self) -> bool {
+ if self == old {
+ return true;
+ }
+ if self.name != old.name {
+ return false;
+ }
+ if self.name == "NUMBER" {
+ return match (self.size, old.size) {
+ (None, _) => true,
+ (Some(p), Some(q)) => {
+ let s = self.scale.unwrap_or(0);
+ let t = old.scale.unwrap_or(0);
+ s >= t && p - s >= q - t
+ }
+ _ => false,
+ };
+ }
+ matches!(self.name.as_str(), "VARCHAR2" | "NVARCHAR2" | "RAW" | "TIMESTAMP")
+ && self.semantics == old.semantics
+ && self.size >= old.size
+ }
+ pub fn family(&self) -> &str {
+ match self.name.as_str() {
+ "CHAR" | "VARCHAR2" | "NCHAR" | "NVARCHAR2" => "text",
+ "NUMBER" => "decimal",
+ "RAW" => "raw",
+ "DATE" => "date",
+ _ => "timestamp",
+ }
+ }
+}
+
+#[derive(Debug, Clone)]
+pub struct ScalarColumn {
+ pub name: String,
+ pub data_type: ScalarType,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum EvolutionDataType {
+ Scalar(ScalarType),
+ Named { owner: String, name: String },
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct EvolutionShape {
+ pub attributes: Vec<(String, EvolutionDataType)>,
+ pub varray: Option<(i32, EvolutionDataType)>,
+ signature: Vec<String>,
+}
+#[derive(Debug, Clone)]
+pub struct EvolutionStep {
+ pub sql: String,
+ pub after: EvolutionShape,
+}
+#[derive(Debug, Clone)]
+pub struct EvolutionSql {
+ pub before: EvolutionShape,
+ pub steps: Vec<EvolutionStep>,
+}
+
+/// Finite, data-preserving differences only. Database restrictions are checked
+/// separately by Core before this preview can become an executable plan.
+pub fn build_type_evolution_sql(owner: &str, name: &str, before: &str, after: &str) -> Result<EvolutionSql, String> {
+ use crate::object_source_sql::{build_oracle_type_management_source, EditableObjectSourceSqlInput};
+ let parse = |source: &str| {
+ let (sql, _) = build_oracle_type_management_source(EditableObjectSourceSqlInput {
+ database_type: crate::models::connection::DatabaseType::Oracle,
+ object_type: crate::types::ObjectSourceKind::Type,
+ schema: Some(owner.into()),
+ name: name.into(),
+ source: source.into(),
+ })?;
+ evolution_shape(owner, &sql)
+ };
+ let before = parse(before)?;
+ let after = parse(after)?;
+ if before.signature != after.signature {
+ return Err("Native evolution cannot change methods, inheritance, AUTHID or TYPE properties. Retain their definitions or prepare an explicit mapping".into());
+ }
+ let mut steps = Vec::new();
+ let target = format!("{}.{}", quote(owner), quote(name));
+ match (&before.varray, &after.varray) {
+ (Some((old_limit, old_type)), Some((new_limit, new_type)))
+ if old_type == new_type && new_limit >= old_limit =>
+ {
+ if new_limit != old_limit {
+ steps.push(EvolutionStep {
+ sql: format!("ALTER TYPE {target} MODIFY LIMIT {new_limit} CASCADE INCLUDING TABLE DATA;"),
+ after: after.clone(),
+ });
+ }
+ }
+ (None, None) => {
+ if after.attributes.len() < before.attributes.len() {
+ return Err("Removing or renaming attributes requires an explicit data mapping".into());
+ }
+ let mut widened = Vec::new();
+ let mut intermediate = before.clone();
+ for (index, ((old_name, old_type), (new_name, new_type))) in
+ before.attributes.iter().zip(&after.attributes).enumerate()
+ {
+ if old_name != new_name {
+ return Err("Native evolution preserves the exact attribute names and order".into());
+ }
+ if old_type != new_type {
+ let (EvolutionDataType::Scalar(old), EvolutionDataType::Scalar(new)) = (old_type, new_type) else {
+ return Err("Changing a referenced UDT requires an explicit mapping".into());
+ };
+ if !native_scalar(new)
+ || !matches!(new.name.as_str(), "NUMBER" | "VARCHAR2" | "RAW")
+ || !new.losslessly_accepts(old)
+ {
+ return Err("The larger type is not a supported lossless widening of both integer digits and scale/length semantics".into());
+ }
+ widened.push(format!("{} {}", quote(new_name), new.sql()));
+ intermediate.attributes[index] = (new_name.clone(), new_type.clone());
+ }
+ }
+ if !widened.is_empty() {
+ steps.push(EvolutionStep {
+ sql: format!(
+ "ALTER TYPE {target} MODIFY ATTRIBUTE ({}) CASCADE INCLUDING TABLE DATA;",
+ widened.join(", ")
+ ),
+ after: intermediate,
+ });
+ }
+ let appended = &after.attributes[before.attributes.len()..];
+ let mut additions = Vec::new();
+ for (name, ty) in appended {
+ let EvolutionDataType::Scalar(ty) = ty else {
+ return Err("A new UDT, REF or nested attribute needs an explicit mapping".into());
+ };
+ if !native_scalar(ty) {
+ return Err("Append a supported built-in scalar attribute; character lengths require explicit BYTE semantics".into());
+ }
+ additions.push(format!("{} {}", quote(name), ty.sql()));
+ }
+ if !additions.is_empty() {
+ steps.push(EvolutionStep {
+ sql: format!(
+ "ALTER TYPE {target} ADD ATTRIBUTE ({}) CASCADE INCLUDING TABLE DATA;",
+ additions.join(", ")
+ ),
+ after,
+ });
+ }
+ }
+ _ => return Err("Native evolution only increases a VARRAY limit without changing its element type".into()),
+ }
+ Ok(EvolutionSql { before, steps })
+}
+
+fn native_scalar(ty: &ScalarType) -> bool {
+ match ty.name.as_str() {
+ "NUMBER" | "DATE" => true,
+ "VARCHAR2" => ty.semantics.as_deref() == Some("BYTE") && ty.size.is_some_and(|n| n <= 4000),
+ "RAW" => ty.size.is_some_and(|n| n <= 2000),
+ _ => false,
+ }
+}
+
+fn type_token(token: &Token) -> String {
+ match token {
+ Token::Word(word) if word.quote_style.is_none() => word.value.to_uppercase(),
+ Token::Word(word) if word.quote_style == Some('"') => quote(&word.value),
+ _ => token.to_string(),
+ }
+}
+
+fn evolution_data_type(cursor: &mut Cursor, owner: &str) -> Result<EvolutionDataType, String> {
+ let mut scalar = cursor.clone();
+ if let Ok(value) = ScalarType::read(&mut scalar) {
+ *cursor = scalar;
+ return Ok(EvolutionDataType::Scalar(value));
+ }
+ let first = cursor.ident()?;
+ let (owner, name) = if cursor.take(Token::Period) { (first, cursor.ident()?) } else { (owner.into(), first) };
+ Ok(EvolutionDataType::Named { owner, name })
+}
+
+fn evolution_shape(owner: &str, sql: &str) -> Result<EvolutionShape, String> {
+ let tokens = Tokenizer::new(&OracleDialect {}, sql).tokenize().map_err(|e| e.to_string())?;
+ let mut signature: Vec<_> = tokens
+ .iter()
+ .filter_map(|token| match token {
+ Token::Whitespace(Whitespace::Space | Whitespace::Tab | Whitespace::Newline) => None,
+ Token::Whitespace(_) => Some(format!("comment:{token}")),
+ _ => None,
+ })
+ .collect();
+ let mut cursor =
+ Cursor { tokens: tokens.into_iter().filter(|t| !matches!(t, Token::Whitespace(_))).collect(), at: 0 };
+ cursor.expect_keyword("CREATE")?;
+ if cursor.keyword("OR") {
+ cursor.expect_keyword("REPLACE")?;
+ }
+ if cursor.keyword("EDITIONABLE") {
+ signature.push("EDITIONABLE".into());
+ } else if cursor.keyword("NONEDITIONABLE") {
+ signature.push("NONEDITIONABLE".into());
+ }
+ cursor.expect_keyword("TYPE")?;
+ cursor.relation()?;
+ let (mut oid, mut authid) = (false, false);
+ loop {
+ if !oid && cursor.keyword("OID") {
+ let Some(Token::SingleQuotedString(value)) = cursor.tokens.get(cursor.at) else {
+ return Err("The unchanged TYPE OID must be a complete literal".into());
+ };
+ signature.push(format!("OID:{value}"));
+ cursor.at += 1;
+ oid = true;
+ } else if !authid && cursor.keyword("AUTHID") {
+ signature.push("AUTHID".into());
+ if cursor.keyword("DEFINER") {
+ signature.push("DEFINER".into());
+ } else {
+ cursor.expect_keyword("CURRENT_USER")?;
+ signature.push("CURRENT_USER".into());
+ }
+ authid = true;
+ } else {
+ break;
+ }
+ }
+ if !cursor.keyword("AS") {
+ cursor.expect_keyword("IS")?;
+ }
+ let mut shape = EvolutionShape { attributes: Vec::new(), varray: None, signature };
+ if cursor.keyword("VARRAY") || cursor.keyword("VARYING") {
+ if matches!(cursor.tokens.get(cursor.at - 1), Some(Token::Word(w)) if w.value.eq_ignore_ascii_case("VARYING")) {
+ cursor.expect_keyword("ARRAY")?;
+ }
+ cursor.expect(Token::LParen)?;
+ let limit = cursor.number()?;
+ if limit < 1 {
+ return Err("The VARRAY limit must be a positive supported integer".into());
+ }
+ cursor.expect(Token::RParen)?;
+ cursor.expect_keyword("OF")?;
+ shape.varray = Some((limit, evolution_data_type(&mut cursor, owner)?));
+ cursor.end()?;
+ shape.signature.push("VARRAY".into());
+ return Ok(shape);
+ }
+ cursor.expect_keyword("OBJECT")?;
+ cursor.expect(Token::LParen)?;
+ let mut names = std::collections::HashSet::new();
+ loop {
+ let method = matches!(cursor.tokens.get(cursor.at), Some(Token::Word(w)) if w.quote_style.is_none() && ["MEMBER", "STATIC", "MAP", "ORDER", "CONSTRUCTOR", "FINAL", "NOT", "OVERRIDING", "INSTANTIABLE"].iter().any(|keyword| w.value.eq_ignore_ascii_case(keyword)));
+ if method {
+ break;
+ }
+ let name = cursor.ident()?;
+ if !names.insert(name.clone()) {
+ return Err("Each native attribute must have a distinct exact name".into());
+ }
+ shape.attributes.push((name, evolution_data_type(&mut cursor, owner)?));
+ if !cursor.take(Token::Comma) {
+ break;
+ }
+ }
+ // The strict source builder has already checked the complete single TYPE.
+ // Any method/property tokens must remain identical; they are never emitted
+ // as arbitrary text in an ALTER clause.
+ while let Some(token) = cursor.tokens.get(cursor.at) {
+ if *token == Token::SemiColon {
+ break;
+ }
+ shape.signature.push(type_token(token));
+ cursor.at += 1;
+ }
+ cursor.end()?;
+ if shape.attributes.is_empty() {
+ return Err("Native evolution needs a complete OBJECT attribute prefix".into());
+ }
+ Ok(shape)
+}
+
+#[cfg(test)]
+mod evolution_tests {
+ use super::*;
+ fn source(shape: &str) -> String {
+ format!("CREATE OR REPLACE TYPE \"App\".\"Root (v1)\" AS {shape};")
+ }
+ #[test]
+ fn native_evolution_does_not_claim_to_apply_changed_source_comments() {
+ let before = source("OBJECT (ID NUMBER)");
+ let after = source("OBJECT (ID NUMBER, /* new source comment */ EXTRA RAW(16))");
+ assert!(build_type_evolution_sql("App", "Root (v1)", &before, &after).is_err());
+ }
+ #[test]
+ fn native_evolution_separates_widening_and_append_without_drop_or_force() {
+ let old = source("OBJECT (\"Id\" NUMBER(8,2), NAME VARCHAR2(20 BYTE), MEMBER FUNCTION F RETURN NUMBER)");
+ let new = source(
+ "OBJECT (\"Id\" NUMBER(10,3), NAME VARCHAR2(40 BYTE), EXTRA RAW(16), MEMBER FUNCTION F RETURN NUMBER)",
+ );
+ let plan = build_type_evolution_sql("App", "Root (v1)", &old, &new).unwrap();
+ assert_eq!(plan.steps.len(), 2);
+ assert_eq!(plan.steps[0].sql, "ALTER TYPE \"App\".\"Root (v1)\" MODIFY ATTRIBUTE (\"Id\" NUMBER(10,3), \"NAME\" VARCHAR2(40 BYTE)) CASCADE INCLUDING TABLE DATA;");
+ assert_eq!(
+ plan.steps[1].sql,
+ "ALTER TYPE \"App\".\"Root (v1)\" ADD ATTRIBUTE (\"EXTRA\" RAW(16)) CASCADE INCLUDING TABLE DATA;"
+ );
+ assert_eq!(plan.steps[0].after.attributes.len(), 2);
+ assert_eq!(plan.steps[1].after.attributes.len(), 3);
+ }
+ #[test]
+ fn native_varray_limit_keeps_the_exact_element_and_increases_only_the_bound() {
+ let old = source("VARRAY(10) OF \"App\".\"Quoted Element\"");
+ let new = source("VARRAY(30) OF \"App\".\"Quoted Element\"");
+ let plan = build_type_evolution_sql("App", "Root (v1)", &old, &new).unwrap();
+ assert_eq!(plan.steps[0].sql, "ALTER TYPE \"App\".\"Root (v1)\" MODIFY LIMIT 30 CASCADE INCLUDING TABLE DATA;");
+ for shape in [
+ "VARRAY(9) OF \"App\".\"Quoted Element\"",
+ "VARRAY(30) OF \"App\".OTHER",
+ "TABLE OF \"App\".\"Quoted Element\"",
+ ] {
+ assert!(build_type_evolution_sql("App", "Root (v1)", &old, &source(shape)).is_err());
+ }
+ }
+ #[test]
+ fn native_evolution_rejects_semantic_changes_and_larger_but_lossy_numeric_dimensions() {
+ let old = source("OBJECT (ID NUMBER(8,2), NAME VARCHAR2(20 BYTE), MEMBER FUNCTION F RETURN NUMBER)");
+ for shape in [
+ "OBJECT (ID NUMBER(9,4), NAME VARCHAR2(20 BYTE), MEMBER FUNCTION F RETURN NUMBER)",
+ "OBJECT (ID NUMBER(7,2), NAME VARCHAR2(20 BYTE), MEMBER FUNCTION F RETURN NUMBER)",
+ "OBJECT (RENAMED NUMBER(8,2), NAME VARCHAR2(20 BYTE), MEMBER FUNCTION F RETURN NUMBER)",
+ "OBJECT (NAME VARCHAR2(20 BYTE), ID NUMBER(8,2), MEMBER FUNCTION F RETURN NUMBER)",
+ "OBJECT (ID NUMBER(8,2), NAME VARCHAR2(20 CHAR), MEMBER FUNCTION F RETURN NUMBER)",
+ "OBJECT (ID NUMBER(8,2), NAME VARCHAR2(20 BYTE), MEMBER FUNCTION F RETURN VARCHAR2)",
+ "OBJECT (ID NUMBER(8,2), NAME VARCHAR2(20 BYTE), EXTRA \"NUMBER\", MEMBER FUNCTION F RETURN NUMBER)",
+ "OBJECT (ID NUMBER(8,2), NAME VARCHAR2(20 BYTE), MEMBER FUNCTION F RETURN NUMBER) NOT FINAL",
+ ] {
+ assert!(build_type_evolution_sql("App", "Root (v1)", &old, &source(shape)).is_err(), "{shape}");
+ }
+ assert!(build_type_evolution_sql("App", "Root (v1)", &old, &(old.clone() + " DROP TABLE X;")).is_err());
+ assert!(build_type_evolution_sql("Other", "Root (v1)", &old, &old).is_err());
+ }
+}
+
+enum Projection {
+ Column(String),
+ Typed(String, ScalarType),
+ Cast(Box<Projection>, ScalarType),
+}
+impl Projection {
+ fn read(cursor: &mut Cursor, depth: usize) -> Result<Self, String> {
+ if depth > 2 {
+ return Err("Nested mapping expressions are not supported".into());
+ }
+ if cursor.keyword("CAST") {
+ cursor.expect(Token::LParen)?;
+ let expression = if cursor.keyword("NULL") {
+ Self::Typed("NULL".into(), ScalarType::parse("NUMBER")?)
+ } else if let Some(Token::SingleQuotedString(text)) = cursor.tokens.get(cursor.at) {
+ let sql = format!("'{}'", text.replace('\'', "''"));
+ cursor.at += 1;
+ Self::Typed(sql, ScalarType::parse(&format!("VARCHAR2({} BYTE)", text.len().max(1)))?)
+ } else if matches!(cursor.tokens.get(cursor.at), Some(Token::Number(..) | Token::Minus)) {
+ let start = cursor.at;
+ cursor.take(Token::Minus);
+ let Some(Token::Number(number, false)) = cursor.tokens.get(cursor.at) else {
+ return Err("Expected a numeric constant".into());
+ };
+ if !number.chars().all(|c| c.is_ascii_digit() || c == '.') {
+ return Err("Use an exact decimal constant without exponent notation".into());
+ }
+ let digits = number.chars().filter(|c| c.is_ascii_digit()).count();
+ let scale = number.split_once('.').map_or(0, |(_, frac)| frac.len());
+ if digits == 0 || digits > 38 || number.matches('.').count() > 1 {
+ return Err("Invalid exact decimal constant".into());
+ }
+ cursor.at += 1;
+ Self::Typed(
+ cursor.tokens[start..cursor.at].iter().map(ToString::to_string).collect::<Vec<_>>().join(""),
+ ScalarType::parse(&format!("NUMBER({},{scale})", digits.max(scale + 1)))?,
+ )
+ } else {
+ Self::read(cursor, depth + 1)?
+ };
+ cursor.expect_keyword("AS")?;
+ let data_type = ScalarType::read(cursor)?;
+ cursor.expect(Token::RParen)?;
+ if let Self::Typed(literal, _) = &expression {
+ if literal == "NULL" {
+ return Ok(Self::Typed(format!("CAST(NULL AS {})", data_type.sql()), data_type));
+ }
+ }
+ return Ok(Self::Cast(Box::new(expression), data_type));
+ }
+ if cursor.keyword("DATE") || cursor.keyword("TIMESTAMP") {
+ let kind = cursor.tokens[cursor.at - 1].to_string().to_uppercase();
+ let Some(Token::SingleQuotedString(text)) = cursor.tokens.get(cursor.at) else {
+ return Err("Expected a typed date/time literal".into());
+ };
+ let date = text.as_bytes();
+ let valid_date = date.len() >= 10
+ && date[..10].iter().enumerate().all(|(i, byte)| {
+ if i == 4 || i == 7 {
+ *byte == b'-'
+ } else {
+ byte.is_ascii_digit()
+ }
+ });
+ let precision = if kind == "DATE" {
+ if !valid_date || date.len() != 10 {
+ return Err("Use a complete YYYY-MM-DD date literal".into());
+ }
+ None
+ } else {
+ let valid_time = date.len() >= 19
+ && date[10..19].iter().enumerate().all(|(i, byte)| match i {
+ 0 => *byte == b' ',
+ 3 | 6 => *byte == b':',
+ _ => byte.is_ascii_digit(),
+ });
+ let fraction = if date.len() == 19 {
+ 0
+ } else if date.get(19) == Some(&b'.')
+ && (21..=29).contains(&date.len())
+ && date[20..].iter().all(u8::is_ascii_digit)
+ {
+ date.len() - 20
+ } else {
+ return Err("Use an exact timestamp literal with at most nine fractional digits".into());
+ };
+ if !valid_date || !valid_time {
+ return Err("Use a complete YYYY-MM-DD HH:MM:SS timestamp literal".into());
+ }
+ Some(fraction)
+ };
+ let sql = format!("{kind} '{}'", text.replace('\'', "''"));
+ cursor.at += 1;
+ return Ok(Self::Typed(
+ sql,
+ ScalarType::parse(&precision.map_or(kind.clone(), |p| format!("TIMESTAMP({p})")))?,
+ ));
+ }
+ Ok(Self::Column(cursor.ident()?))
+ }
+ fn checked(&self, columns: &[ScalarColumn]) -> Result<(String, ScalarType), String> {
+ match self {
+ Self::Column(name) => columns
+ .iter()
+ .find(|c| c.name == *name)
+ .map(|c| (quote(name), c.data_type.clone()))
+ .ok_or_else(|| format!("Unregistered EXPECTED column: {name}")),
+ Self::Typed(sql, ty) => Ok((sql.clone(), ty.clone())),
+ Self::Cast(inner, ty) => {
+ let (sql, old) = inner.checked(columns)?;
+ if !ty.losslessly_accepts(&old) {
+ return Err("The CAST is not proven lossless for the complete registered source type".into());
+ }
+ Ok((format!("CAST({sql} AS {})", ty.sql()), ty.clone()))
+ }
+ }
+ }
+}
+
+/// A tiny, fully consumed INSERT/SELECT AST. Live object/implicit-execution and
+/// empty-target checks belong to the Core reader immediately before dispatch.
+pub fn validate_scalar_insert(
+ sql: &str,
+ target: (&str, &str),
+ expected: (&str, &str),
+ target_columns: &[ScalarColumn],
+ expected_columns: &[ScalarColumn],
+) -> Result<String, String> {
+ let mut cursor = Cursor::new(sql)?;
+ cursor.expect_keyword("INSERT")?;
+ cursor.expect_keyword("INTO")?;
+ if cursor.relation()? != (target.0.into(), target.1.into()) {
+ return Err("INSERT target is not the registered target relation".into());
+ }
+ cursor.expect(Token::LParen)?;
+ let mut columns = vec![cursor.ident()?];
+ while cursor.take(Token::Comma) {
+ columns.push(cursor.ident()?);
+ }
+ cursor.expect(Token::RParen)?;
+ cursor.expect_keyword("SELECT")?;
+ let mut projection = vec![Projection::read(&mut cursor, 0)?];
+ while cursor.take(Token::Comma) {
+ projection.push(Projection::read(&mut cursor, 0)?);
+ }
+ cursor.expect_keyword("FROM")?;
+ if cursor.relation()? != (expected.0.into(), expected.1.into()) {
+ return Err("SELECT source is not the registered EXPECTED relation".into());
+ }
+ cursor.end()?;
+ let names: std::collections::HashSet<_> = columns.iter().collect();
+ if columns.len() != target_columns.len() || names.len() != columns.len() || projection.len() != columns.len() {
+ return Err("Supply every target scalar column exactly once".into());
+ }
+ let mut checked = Vec::new();
+ for (name, expression) in columns.iter().zip(projection) {
+ let column = target_columns.iter().find(|c| &c.name == name).ok_or("Unknown target column")?;
+ let (sql, data_type) = expression.checked(expected_columns)?;
+ if !column.data_type.losslessly_accepts(&data_type) {
+ return Err(format!("Target column {name} cannot accept the full expression type without loss"));
+ }
+ checked.push(sql);
+ }
+ Ok(format!(
+ "INSERT INTO {}.{} ({}) SELECT {} FROM {}.{};",
+ quote(target.0),
+ quote(target.1),
+ columns.iter().map(|c| quote(c)).collect::<Vec<_>>().join(", "),
+ checked.join(", "),
+ quote(expected.0),
+ quote(expected.1)
+ ))
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ const OB_TABLE_SUFFIX: &str = "COMPRESS FOR ARCHIVE REPLICA_NUM = 1 BLOCK_SIZE = 16384 USE_BLOOM_FILTER = FALSE TABLET_SIZE = 134217728 PCTFREE = 0";
+ #[test]
+ fn oceanbase_native_insert_definition_proves_simple_scalar_columns_and_keys() {
+ for body in [
+ "\"ID\" NUMBER, \"LABEL\" VARCHAR2(40), PRIMARY KEY (\"ID\")",
+ "\"ID\" NUMBER(38,4) NOT NULL, \"LABEL\" VARCHAR2(80 BYTE) NULL, CONSTRAINT PK_ID PRIMARY KEY (\"ID\"), UNIQUE (\"ID\", \"LABEL\")",
+ ] {
+ let ddl = format!("CREATE TABLE APP.RESULT ({body}) {OB_TABLE_SUFFIX}");
+ assert_eq!(oceanbase_scalar_insert_columns("APP", "RESULT", &ddl), Ok(vec!["ID".into(), "LABEL".into()]));
+ }
+ }
+ #[test]
+ fn oceanbase_native_insert_definition_rejects_unverified_execution_or_columns() {
+ for body in [
+ "ID NUMBER DEFAULT APP.F()",
+ "ID NUMBER GENERATED BY DEFAULT AS IDENTITY",
+ "ID NUMBER GENERATED ALWAYS AS (1) VIRTUAL",
+ "ID NUMBER CHECK (APP.F(ID)=1)",
+ "ID APP.OBJECT_TYPE",
+ "ID NUMBER, ID NUMBER",
+ "ID NUMBER, PRIMARY KEY (MISSING)",
+ "ID NUMBER, UNIQUE (ID,ID)",
+ "ID NUMBER, CONSTRAINT FK FOREIGN KEY (ID) REFERENCES OTHER(ID)",
+ "ID NUMBER, CONSTRAINT C CHECK (ID>0)",
+ "ID NUMBER,",
+ "",
+ ] {
+ let ddl = format!("CREATE TABLE APP.RESULT ({body}) {OB_TABLE_SUFFIX}");
+ assert!(oceanbase_scalar_insert_columns("APP", "RESULT", &ddl).is_err(), "{ddl}");
+ }
+ let readonly = format!("CREATE TABLE APP.RESULT (ID NUMBER) {OB_TABLE_SUFFIX} READ ONLY");
+ assert!(oceanbase_scalar_insert_columns("APP", "RESULT", &readonly).is_err());
+ }
+ #[test]
+ fn oceanbase_native_readonly_requires_complete_exact_definition() {
+ for (declaration, state) in [("", false), (" READ WRITE;", false), (" READ ONLY", true)] {
+ for relation in ["\"APP\".\"Old table\"", "\"Old table\""] {
+ let ddl = format!("CREATE TABLE {relation} (\"ID\" NUMBER(38,4), \"READ ONLY\" VARCHAR2(80) DEFAULT 'READ ONLY') {OB_TABLE_SUFFIX}{declaration}");
+ assert_eq!(oceanbase_table_read_only_from_ddl("APP", "Old table", &ddl), Ok(state));
+ }
+ }
+ for ddl in [
+ format!("CREATE TABLE APP.OLD (ID NUMBER) {OB_TABLE_SUFFIX} READ ONLY"),
+ format!("CREATE TABLE OTHER.\"Old table\" (ID NUMBER) {OB_TABLE_SUFFIX} READ ONLY"),
+ format!("CREATE TABLE \"Old table\" (ID NUMBER {OB_TABLE_SUFFIX} READ ONLY"),
+ format!("CREATE TABLE \"Old table\" () {OB_TABLE_SUFFIX} READ ONLY"),
+ format!("CREATE TABLE \"Old table\" (ID NUMBER) {OB_TABLE_SUFFIX} READ ONLY; DROP TABLE APP.X"),
+ format!("CREATE TABLE \"Old table\" (ID NUMBER) {OB_TABLE_SUFFIX} READ ONLY READ WRITE"),
+ format!("CREATE TABLE \"Old table\" (ID NUMBER) {OB_TABLE_SUFFIX} PCTFREE=0 READ ONLY"),
+ format!("CREATE TABLE \"Old table\" (ID NUMBER) {OB_TABLE_SUFFIX} /* READ ONLY */"),
+ format!("CREATE TABLE \"Old table\" (ID NUMBER) {OB_TABLE_SUFFIX} UNKNOWN_OPTION=1 READ ONLY"),
+ "CREATE TABLE \"Old table\" (ID NUMBER) READ ONLY".into(),
+ "CREATE TABLE \"Old table\" (ID NUMBER)".into(),
+ ] {
+ assert!(oceanbase_table_read_only_from_ddl("APP", "Old table", &ddl).is_err(), "{ddl}");
+ }
+ }
+ fn columns() -> Vec<ScalarColumn> {
+ vec![
+ ScalarColumn { name: "ID".into(), data_type: ScalarType::parse("NUMBER(30,0)").unwrap() },
+ ScalarColumn { name: "LABEL".into(), data_type: ScalarType::parse("VARCHAR2(80 BYTE)").unwrap() },
+ ]
+ }
+ #[test]
+ fn accepts_complete_projection_and_proven_lossless_cast() {
+ let sql = validate_scalar_insert(
+ "INSERT INTO APP.RESULT(ID,LABEL) SELECT CAST(ID AS NUMBER(32,0)), LABEL FROM APP.EXPECTED",
+ ("APP", "RESULT"),
+ ("APP", "EXPECTED"),
+ &[
+ ScalarColumn { name: "ID".into(), data_type: ScalarType::parse("NUMBER(38,0)").unwrap() },
+ columns().remove(1),
+ ],
+ &columns(),
+ )
+ .unwrap();
+ assert!(sql.starts_with("INSERT INTO \"APP\".\"RESULT\""));
+ }
+ #[test]
+ fn typed_constants_are_bounded_and_fractional_timestamp_precision_is_not_silently_lost() {
+ let columns =
+ vec![ScalarColumn { name: "VALUE".into(), data_type: ScalarType::parse("TIMESTAMP(9)").unwrap() }];
+ let sql = "INSERT INTO APP.RESULT(VALUE) SELECT TIMESTAMP '2026-10-20 12:13:14.123456789' FROM APP.EXPECTED";
+ assert!(validate_scalar_insert(sql, ("APP", "RESULT"), ("APP", "EXPECTED"), &columns, &columns).is_ok());
+ let narrow = vec![ScalarColumn { name: "VALUE".into(), data_type: ScalarType::parse("TIMESTAMP(6)").unwrap() }];
+ assert!(validate_scalar_insert(sql, ("APP", "RESULT"), ("APP", "EXPECTED"), &narrow, &columns).is_err());
+ let number = vec![ScalarColumn { name: "VALUE".into(), data_type: ScalarType::parse("NUMBER(38,0)").unwrap() }];
+ assert!(validate_scalar_insert(
+ "INSERT INTO APP.RESULT(VALUE) SELECT CAST(900719925474099312345 AS NUMBER(38,0)) FROM APP.EXPECTED",
+ ("APP", "RESULT"),
+ ("APP", "EXPECTED"),
+ &number,
+ &number
+ )
+ .is_ok());
+ }
+ #[test]
+ fn number_scale_must_preserve_integer_digits_as_well_as_fraction() {
+ assert!(!ScalarType::parse("NUMBER(30,4)")
+ .unwrap()
+ .losslessly_accepts(&ScalarType::parse("NUMBER(30,0)").unwrap()));
+ assert!(ScalarType::parse("NUMBER(34,4)")
+ .unwrap()
+ .losslessly_accepts(&ScalarType::parse("NUMBER(30,0)").unwrap()));
+ assert!(!ScalarType::parse("VARCHAR2(90 CHAR)")
+ .unwrap()
+ .losslessly_accepts(&ScalarType::parse("VARCHAR2(80 BYTE)").unwrap()));
+ }
+ #[test]
+ fn rejects_every_non_grammar_write_or_hidden_expression() {
+ for sql in [
+ "INSERT INTO APP.RESULT(ID,LABEL) SELECT ID,LABEL FROM APP.EXPECTED; DROP TABLE APP.X",
+ "INSERT INTO APP.RESULT(ID,LABEL) SELECT ID,LABEL FROM APP.EXPECTED WHERE 1=1",
+ "INSERT INTO APP.RESULT(ID,LABEL) SELECT ID,F(LABEL) FROM APP.EXPECTED",
+ "INSERT INTO APP.RESULT(ID,LABEL) SELECT ID,APP.F(LABEL) FROM APP.EXPECTED",
+ "INSERT /*+ hint */ INTO APP.RESULT(ID,LABEL) SELECT ID,LABEL FROM APP.EXPECTED",
+ "INSERT INTO APP.RESULT(ID,LABEL) SELECT * FROM APP.EXPECTED",
+ "INSERT INTO APP.RESULT(ID,LABEL) SELECT ID,LABEL FROM APP.EXPECTED@REMOTE",
+ "INSERT INTO APP.RESULT(ID,LABEL) SELECT ID,LABEL FROM APP.EXPECTED JOIN APP.X ON 1=1",
+ "INSERT INTO APP.RESULT(ID,LABEL) SELECT ID,(SELECT LABEL FROM APP.X) FROM APP.EXPECTED",
+ "INSERT INTO APP.RESULT(ID,LABEL) SELECT ID,SEQ.NEXTVAL FROM APP.EXPECTED",
+ "INSERT INTO APP.RESULT(ID,LABEL) SELECT CAST(ID AS NUMBER(30,4)),LABEL FROM APP.EXPECTED",
+ "INSERT INTO APP.RESULT(ID,LABEL) SELECT CAST(ID AS \"NUMBER\"(38,0)),LABEL FROM APP.EXPECTED",
+ "INSERT INTO APP.RESULT(ID) SELECT ID FROM APP.EXPECTED",
+ "INSERT INTO APP.RESULT(ID,ID) SELECT ID,ID FROM APP.EXPECTED",
+ "UPDATE APP.RESULT SET ID=1",
+ "BEGIN NULL; END;",
+ ] {
+ assert!(
+ validate_scalar_insert(sql, ("APP", "RESULT"), ("APP", "EXPECTED"), &columns(), &columns()).is_err(),
+ "{sql}"
+ );
+ }
+ }
+}
diff --git a/crates/dbx-sql-core/src/sql.rs b/crates/dbx-sql-core/src/sql.rs
index cfdf156a43..32d7d341ad 100644
--- a/crates/dbx-sql-core/src/sql.rs
+++ b/crates/dbx-sql-core/src/sql.rs
@@ -3082,7 +3082,7 @@ fn starts_with_postgres_dollar_quoted_routine_prefix(sql: &str) -> bool {
&& block.tokens.iter().rev().find_map(OraclePlSqlToken::as_word) == Some("AS")
}
-fn oracle_plsql_block_is_complete(sql: &str) -> bool {
+pub(crate) fn oracle_plsql_block_is_complete(sql: &str) -> bool {
OraclePlSqlBlock::parse(sql).is_complete()
}
diff --git a/crates/dbx-sql-schema/src/db_admin_sql.rs b/crates/dbx-sql-schema/src/db_admin_sql.rs
index 1765a8566b..7956135795 100644
--- a/crates/dbx-sql-schema/src/db_admin_sql.rs
+++ b/crates/dbx-sql-schema/src/db_admin_sql.rs
@@ -15,6 +15,8 @@ pub enum DatabaseObjectType {
Procedure,
Function,
Event,
+ Type,
+ TypeBody,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
@@ -95,6 +97,45 @@ pub struct DropObjectSqlOptions {
pub identifier_quote: Option<String>,
}
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeGrantSqlOptions {
+ pub database_type: DatabaseType,
+ pub owner: String,
+ pub type_name: String,
+ pub grantee: String,
+ pub privilege: String,
+ #[serde(default)]
+ pub grantable: bool,
+}
+
+pub fn build_oracle_type_grant_sql(options: OracleTypeGrantSqlOptions) -> Result<String, String> {
+ if !matches!(options.database_type, DatabaseType::Oracle | DatabaseType::OceanbaseOracle | DatabaseType::Dameng) {
+ return Err("TYPE EXECUTE grants are supported only for Oracle-family databases.".to_string());
+ }
+ if options.owner.trim().is_empty() || options.type_name.trim().is_empty() || options.grantee.trim().is_empty() {
+ return Err("TYPE owner, name, and grantee are required.".to_string());
+ }
+ let privilege = options.privilege.to_ascii_uppercase();
+ if !matches!(privilege.as_str(), "EXECUTE" | "DEBUG" | "UNDER")
+ || (options.database_type == DatabaseType::Dameng && privilege != "EXECUTE")
+ {
+ return Err("Unsupported direct TYPE privilege for this database.".into());
+ }
+ let object = format!(
+ "{}.{}",
+ quote_table_identifier(Some(options.database_type), &options.owner),
+ quote_table_identifier(Some(options.database_type), &options.type_name),
+ );
+ let grantee = if options.grantee == "PUBLIC" {
+ "PUBLIC".into()
+ } else {
+ quote_table_identifier(Some(options.database_type), &options.grantee)
+ };
+ let option = if options.grantable { " WITH GRANT OPTION" } else { "" };
+ Ok(format!("GRANT {privilege} ON {object} TO {grantee}{option};"))
+}
+
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TableAdminSqlOptions {
@@ -456,8 +497,15 @@ pub fn build_drop_object_sql(options: DropObjectSqlOptions) -> String {
} else {
String::new()
};
+ let restrict = if options.database_type == Some(DatabaseType::Dameng)
+ && matches!(options.object_type, DatabaseObjectType::Type | DatabaseObjectType::TypeBody)
+ {
+ " RESTRICT"
+ } else {
+ ""
+ };
format!(
- "DROP {} {}{};",
+ "DROP {} {}{}{};",
object_type_keyword(options.object_type),
qualified_name_with_quote(
options.database_type,
@@ -465,7 +513,8 @@ pub fn build_drop_object_sql(options: DropObjectSqlOptions) -> String {
&options.name,
options.identifier_quote.as_deref(),
),
- signature
+ signature,
+ restrict
)
}
@@ -1316,6 +1365,8 @@ fn object_type_keyword(object_type: DatabaseObjectType) -> &'static str {
DatabaseObjectType::Procedure => "PROCEDURE",
DatabaseObjectType::Function => "FUNCTION",
DatabaseObjectType::Event => "EVENT",
+ DatabaseObjectType::Type => "TYPE",
+ DatabaseObjectType::TypeBody => "TYPE BODY",
}
}
@@ -2286,6 +2337,24 @@ mod tests {
}),
"DROP FUNCTION \"public\".\"calc\"(integer, integer);"
);
+ for (database_type, object_type, expected) in [
+ (DatabaseType::Oracle, DatabaseObjectType::Type, "DROP TYPE \"APP\".\"Mixed Type\";"),
+ (DatabaseType::OceanbaseOracle, DatabaseObjectType::TypeBody, "DROP TYPE BODY \"APP\".\"Mixed Type\";"),
+ (DatabaseType::Dameng, DatabaseObjectType::Type, "DROP TYPE \"APP\".\"Mixed Type\" RESTRICT;"),
+ (DatabaseType::Dameng, DatabaseObjectType::TypeBody, "DROP TYPE BODY \"APP\".\"Mixed Type\" RESTRICT;"),
+ ] {
+ assert_eq!(
+ build_drop_object_sql(DropObjectSqlOptions {
+ database_type: Some(database_type),
+ object_type,
+ schema: Some("APP".to_string()),
+ name: "Mixed Type".to_string(),
+ signature: None,
+ identifier_quote: None,
+ }),
+ expected,
+ );
+ }
assert_eq!(
build_drop_database_sql(DatabaseNameSqlOptions {
database_type: Some(DatabaseType::Mysql),
@@ -2375,6 +2444,61 @@ mod tests {
);
}
+ #[test]
+ fn builds_type_execute_grants_with_database_native_identifier_quotes() {
+ for database_type in [DatabaseType::Oracle, DatabaseType::OceanbaseOracle, DatabaseType::Dameng] {
+ assert_eq!(
+ build_oracle_type_grant_sql(OracleTypeGrantSqlOptions {
+ database_type,
+ owner: "APP".into(),
+ type_name: "Mixed Type".into(),
+ grantee: "MIG_OTHER".into(),
+ privilege: "EXECUTE".into(),
+ grantable: true,
+ })
+ .unwrap(),
+ "GRANT EXECUTE ON \"APP\".\"Mixed Type\" TO \"MIG_OTHER\" WITH GRANT OPTION;"
+ );
+ }
+ assert!(build_oracle_type_grant_sql(OracleTypeGrantSqlOptions {
+ database_type: DatabaseType::Mysql,
+ owner: "APP".into(),
+ type_name: "T".into(),
+ grantee: "U".into(),
+ privilege: "EXECUTE".into(),
+ grantable: false,
+ })
+ .is_err());
+ for privilege in ["DEBUG", "UNDER"] {
+ let input = OracleTypeGrantSqlOptions {
+ database_type: DatabaseType::Oracle,
+ owner: "APP".into(),
+ type_name: "T".into(),
+ grantee: "PUBLIC".into(),
+ privilege: privilege.into(),
+ grantable: false,
+ };
+ assert_eq!(
+ build_oracle_type_grant_sql(input.clone()).unwrap(),
+ format!("GRANT {privilege} ON \"APP\".\"T\" TO PUBLIC;")
+ );
+ assert!(build_oracle_type_grant_sql(OracleTypeGrantSqlOptions {
+ database_type: DatabaseType::Dameng,
+ ..input
+ })
+ .is_err());
+ }
+ assert!(build_oracle_type_grant_sql(OracleTypeGrantSqlOptions {
+ database_type: DatabaseType::Oracle,
+ owner: "APP".into(),
+ type_name: "T".into(),
+ grantee: "USER".into(),
+ privilege: "EXECUTE; DROP USER X".into(),
+ grantable: false
+ })
+ .is_err());
+ }
+
#[test]
fn builds_drop_table_child_object_sql() {
assert_eq!(
diff --git a/crates/dbx-sql/src/lib.rs b/crates/dbx-sql/src/lib.rs
index 346c6c046a..1bce9f8b10 100644
--- a/crates/dbx-sql/src/lib.rs
+++ b/crates/dbx-sql/src/lib.rs
@@ -1,9 +1,9 @@
#![recursion_limit = "256"]
pub use dbx_sql_core::{
- dml_preview_sql, mysql_ddl_normalize, mysql_event_sql, object_source_sql, oracle_view_rename, query_execution_sql,
- sql, sql_analysis, sql_diagnostics, sql_editability, sql_error_position, sql_risk, sqlserver_temporal, tdsql_mysql,
- value_literals,
+ dml_preview_sql, mysql_ddl_normalize, mysql_event_sql, object_source_sql, oracle_type_migration_sql,
+ oracle_view_rename, query_execution_sql, sql, sql_analysis, sql_diagnostics, sql_editability, sql_error_position,
+ sql_risk, sqlserver_temporal, tdsql_mysql, value_literals,
};
pub use dbx_sql_data::{
data_grid_extractors, data_grid_sql, database_search_columns_sql, database_search_probe_sql, database_search_sql,
diff --git a/crates/dbx-tauri-schema/src/commands.rs b/crates/dbx-tauri-schema/src/commands.rs
index 37c89fc932..5f7d555801 100644
--- a/crates/dbx-tauri-schema/src/commands.rs
+++ b/crates/dbx-tauri-schema/src/commands.rs
@@ -424,6 +424,49 @@ pub async fn get_custom_type_details(
dbx_core::schema::get_custom_type_details_core(&state, &connection_id, &database, &schema, &name).await
}
+#[tauri::command]
+pub async fn get_oracle_type_management_snapshot(
+ state: State<'_, Arc<AppState>>,
+ connection_id: String,
+ database: String,
+ owner: String,
+ name: String,
+ known_objects: Option<Vec<db::OracleTypeManagementObjectKey>>,
+) -> Result<db::OracleTypeManagementSnapshot, String> {
+ dbx_core::schema::get_oracle_type_management_snapshot_with_objects_core(
+ &state,
+ &connection_id,
+ &database,
+ &owner,
+ &name,
+ known_objects.as_deref().unwrap_or_default(),
+ )
+ .await
+}
+
+#[tauri::command]
+pub fn build_oracle_type_management_sql(
+ input: db::OracleTypeManagementSqlInput,
+) -> Result<db::OracleTypeManagementSqlResult, String> {
+ dbx_core::schema::build_oracle_type_management_sql(input)
+}
+
+#[tauri::command]
+pub async fn verify_oracle_type_data(
+ state: State<'_, Arc<AppState>>,
+ input: db::OracleTypeDataRequest,
+) -> Result<db::OracleTypeDataResult, String> {
+ dbx_core::schema::verify_oracle_type_data_core(&state, input).await
+}
+
+#[tauri::command]
+pub async fn prepare_oracle_type_evolution(
+ state: State<'_, Arc<AppState>>,
+ input: db::OracleTypeEvolutionRequest,
+) -> Result<db::OracleTypeEvolutionManifest, String> {
+ dbx_core::schema::prepare_oracle_type_evolution_core(&state, input).await
+}
+
#[tauri::command]
pub async fn get_columns(
state: State<'_, Arc<AppState>>,
diff --git a/crates/dbx-tauri-schema/src/lib.rs b/crates/dbx-tauri-schema/src/lib.rs
index 0962014ebd..e6d17d98c1 100644
--- a/crates/dbx-tauri-schema/src/lib.rs
+++ b/crates/dbx-tauri-schema/src/lib.rs
@@ -32,6 +32,10 @@ define_registry![
get_object_source,
get_event_info,
get_custom_type_details,
+ get_oracle_type_management_snapshot,
+ build_oracle_type_management_sql,
+ verify_oracle_type_data,
+ prepare_oracle_type_evolution,
list_schemas,
list_schema_infos,
list_data_types,
@@ -92,7 +96,7 @@ mod tests {
#[test]
fn handles_only_schema_commands() {
- assert_eq!(COMMANDS.len(), 56);
+ assert_eq!(COMMANDS.len(), 60);
assert!(handles("list_databases"));
assert!(handles("load_schema_diff_routines"));
assert!(handles("prepare_oracle_routine_save"));
@@ -102,6 +106,14 @@ mod tests {
assert!(handles("observe_oracle_routine_operation"));
assert!(handles("update_oracle_routine_operation_references"));
assert!(handles("list_event_triggers"));
+ for command in [
+ "get_oracle_type_management_snapshot",
+ "build_oracle_type_management_sql",
+ "verify_oracle_type_data",
+ "prepare_oracle_type_evolution",
+ ] {
+ assert!(handles(command), "{command}");
+ }
assert!(!handles("prepare_schema_diff"));
assert!(!handles("load_connections"));
}
diff --git a/crates/dbx-types/src/types.rs b/crates/dbx-types/src/types.rs
index fdbbcde86e..6c140b9231 100644
--- a/crates/dbx-types/src/types.rs
+++ b/crates/dbx-types/src/types.rs
@@ -1,3 +1,4 @@
+use crate::models::connection::DatabaseType;
use serde::{Deserialize, Serialize};
/// Agent drivers can serialize an empty native slice as JSON `null` instead of
@@ -1188,6 +1189,9 @@ pub enum CustomTypeKind {
Enum,
Range,
Multirange,
+ Object,
+ Collection,
+ Other,
}
impl CustomTypeKind {
@@ -1199,6 +1203,9 @@ impl CustomTypeKind {
Self::Enum => "enum",
Self::Range => "range",
Self::Multirange => "multirange",
+ Self::Object => "object",
+ Self::Collection => "collection",
+ Self::Other => "other",
}
}
}
@@ -1277,6 +1284,387 @@ pub struct CustomTypeDdl {
pub warnings: Vec<String>,
}
+/// Completeness of one Oracle-family dictionary section, within the current
+/// user's visible scope. An unavailable section retains its read error.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum TypeMetadataState {
+ Available,
+ Incomplete,
+ Unavailable,
+ Unsupported,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TypeMetadataRead {
+ pub state: TypeMetadataState,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub reason: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeAttribute {
+ pub name: String,
+ pub ordinal: Option<i32>,
+ pub type_owner: Option<String>,
+ pub type_name: Option<String>,
+ pub type_modifier: Option<String>,
+ pub length: Option<i64>,
+ pub precision: Option<i32>,
+ pub scale: Option<i32>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeMethodParameter {
+ pub name: Option<String>,
+ pub ordinal: Option<i32>,
+ pub mode: Option<String>,
+ pub type_owner: Option<String>,
+ pub type_name: Option<String>,
+ pub type_modifier: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeMethod {
+ pub name: String,
+ pub number: Option<i32>,
+ pub kind: Option<String>,
+ pub parameter_count: Option<u32>,
+ pub result_count: Option<u32>,
+ pub parameters: Vec<OracleTypeMethodParameter>,
+ pub results: Vec<OracleTypeMethodParameter>,
+ pub parameters_read: TypeMetadataRead,
+ pub results_read: TypeMetadataRead,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeCollection {
+ pub kind: Option<String>,
+ pub upper_bound: Option<i64>,
+ pub element_owner: Option<String>,
+ pub element_name: Option<String>,
+ pub element_modifier: Option<String>,
+ pub length: Option<i64>,
+ pub precision: Option<i32>,
+ pub scale: Option<i32>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeMetadata {
+ pub status: Option<String>,
+ pub type_code: Option<String>,
+ pub is_final: Option<bool>,
+ pub instantiable: Option<bool>,
+ pub supertype_owner: Option<String>,
+ pub supertype_name: Option<String>,
+ pub attribute_count: Option<u32>,
+ pub method_count: Option<u32>,
+ /// `false` means no body in this successful dictionary read, not globally absent.
+ pub body_visible: Option<bool>,
+ pub body_status: Option<String>,
+ pub properties_read: TypeMetadataRead,
+ pub body_read: TypeMetadataRead,
+ pub attributes_read: TypeMetadataRead,
+ pub methods_read: TypeMetadataRead,
+ pub collection_read: TypeMetadataRead,
+ pub attributes: Vec<OracleTypeAttribute>,
+ pub methods: Vec<OracleTypeMethod>,
+ pub collection: Option<OracleTypeCollection>,
+}
+
+/// A readback value used by the controlled Oracle-family TYPE manager. `None`
+/// is kept distinct from an empty value when the relevant dictionary read is
+/// incomplete or unavailable.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeManagementSnapshot {
+ pub target: OracleTypeManagementTarget,
+ /// Catalogues queried by this snapshot are limited to the current user's visible scope.
+ pub visibility_scope: String,
+ pub acting_user: Option<String>,
+ pub acting_user_read: TypeMetadataRead,
+ pub details: Option<CustomTypeDetails>,
+ pub details_read: TypeMetadataRead,
+ pub type_source: Option<String>,
+ pub type_source_read: TypeMetadataRead,
+ pub body_source: Option<String>,
+ pub body_source_read: TypeMetadataRead,
+ pub objects: Vec<OracleTypeManagementObject>,
+ pub dependencies: Vec<OracleTypeManagementDependency>,
+ pub dependencies_read: TypeMetadataRead,
+ pub persistent_references: Vec<OracleTypeManagementReference>,
+ pub persistent_references_read: TypeMetadataRead,
+ pub direct_privileges: Vec<OracleTypeManagementPrivilege>,
+ pub privileges_read: TypeMetadataRead,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum OracleTypeManagementSqlOperation {
+ SaveSpec,
+ SaveBody,
+ DropSpec,
+ DropBody,
+ GrantExecute,
+ GrantPrivilege,
+ RebuildSource,
+ CompileSpec,
+ CompileTrigger,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeManagementSqlInput {
+ pub database_type: DatabaseType,
+ pub operation: OracleTypeManagementSqlOperation,
+ pub owner: String,
+ pub name: String,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub source: Option<String>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub grantee: Option<String>,
+ #[serde(default)]
+ pub grantable: bool,
+ #[serde(default)]
+ pub object_type: Option<ObjectSourceKind>,
+ #[serde(default)]
+ pub privilege: Option<String>,
+ #[serde(default)]
+ pub trigger_enabled: Option<bool>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeManagementSqlResult {
+ pub statements: Vec<String>,
+ pub source_fingerprint: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeManagementTarget {
+ pub connection_id: String,
+ pub database: String,
+ pub owner: String,
+ pub name: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeManagementObjectKey {
+ pub owner: String,
+ pub name: String,
+ pub object_type: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeManagementSnapshotRequest {
+ pub target: OracleTypeManagementTarget,
+ #[serde(default)]
+ pub known_objects: Vec<OracleTypeManagementObjectKey>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeManagementObject {
+ pub owner: String,
+ pub name: String,
+ pub object_type: String,
+ pub exists: Option<bool>,
+ pub object_id: Option<String>,
+ pub status: Option<String>,
+ pub status_read: TypeMetadataRead,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub trigger_enabled: Option<bool>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub trigger_enabled_read: Option<TypeMetadataRead>,
+ pub source: Option<String>,
+ pub source_read: TypeMetadataRead,
+ pub source_fingerprint: Option<String>,
+ pub errors: Vec<OracleTypeManagementError>,
+ pub errors_read: TypeMetadataRead,
+ #[serde(default)]
+ pub direct_privileges: Vec<OracleTypeManagementPrivilege>,
+ pub privileges_read: TypeMetadataRead,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeManagementError {
+ pub line: u32,
+ pub position: u32,
+ pub text: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeManagementDependency {
+ pub owner: String,
+ pub name: String,
+ pub object_type: String,
+ pub referenced_owner: String,
+ pub referenced_name: String,
+ pub referenced_type: String,
+ pub referenced_link: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeManagementReference {
+ pub owner: String,
+ pub table_name: String,
+ pub column_name: Option<String>,
+ pub data_type_owner: Option<String>,
+ pub data_type: Option<String>,
+ pub table_status: Option<String>,
+ pub table_read_only: Option<bool>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeManagementPrivilege {
+ pub grantee: String,
+ pub privilege: String,
+ pub grantable: Option<bool>,
+ pub hierarchy: Option<bool>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub grantor: Option<String>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub privilege_id: Option<String>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub privilege_type: Option<String>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub column_id: Option<String>,
+}
+
+/// Exact durable scalar relations used only by a TYPE migration. No business rows
+/// are serialized into this manifest or returned by the verification endpoint.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeDataRelationKey {
+ pub owner: String,
+ pub name: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeDataField {
+ pub source_path: Vec<String>,
+ #[serde(default)]
+ pub object_null: bool,
+ pub old_column: String,
+ pub expected_column: String,
+ pub target_path: Vec<String>,
+ #[serde(default)]
+ pub target_object_null: bool,
+ #[serde(default)]
+ pub unchanged: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeDataMappingInput {
+ pub id: String,
+ pub source: OracleTypeDataRelationKey,
+ pub old: OracleTypeDataRelationKey,
+ pub expected: OracleTypeDataRelationKey,
+ pub target: OracleTypeDataRelationKey,
+ pub fields: Vec<OracleTypeDataField>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeDataProjection {
+ pub path: Vec<String>,
+ pub object_null: bool,
+ pub data_type: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeDataRelation {
+ pub relation: OracleTypeDataRelationKey,
+ pub object_id: String,
+ pub read_only: Option<bool>,
+ /// Directly inspectable metadata, not a digest of ordinary definitions.
+ pub structure: String,
+ pub projection: Vec<OracleTypeDataProjection>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeDataBaseline {
+ pub relation: OracleTypeDataRelation,
+ pub row_count: u32,
+ pub fingerprint: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeDataManifest {
+ pub mapping: OracleTypeDataMappingInput,
+ pub original: OracleTypeDataBaseline,
+ pub old: OracleTypeDataBaseline,
+ pub expected: OracleTypeDataBaseline,
+ #[serde(default)]
+ pub prepared_target: Option<OracleTypeDataBaseline>,
+ #[serde(default)]
+ pub verified_target: Option<OracleTypeDataBaseline>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeDataRequest {
+ pub target: OracleTypeManagementTarget,
+ pub action: String,
+ #[serde(default)]
+ pub relation: Option<OracleTypeDataRelationKey>,
+ #[serde(default)]
+ pub mapping: Option<OracleTypeDataMappingInput>,
+ #[serde(default)]
+ pub manifest: Option<OracleTypeDataManifest>,
+ #[serde(default)]
+ pub sql: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeDataResult {
+ pub relation: Option<OracleTypeDataRelation>,
+ pub manifest: Option<OracleTypeDataManifest>,
+ pub insert_sql: Option<String>,
+}
+
+/// Native ALTER TYPE never exports UDT values or requires user-prepared baselines.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeEvolutionManifest {
+ pub target: OracleTypeManagementTarget,
+ pub source_before: String,
+ pub source_after: String,
+ pub statements: Vec<String>,
+ /// Inspectable identity/restriction metadata and row counts, not a data hash.
+ pub metadata: String,
+ pub phase: usize,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OracleTypeEvolutionRequest {
+ pub target: OracleTypeManagementTarget,
+ pub source_before: String,
+ pub source_after: String,
+ #[serde(default)]
+ pub manifest: Option<OracleTypeEvolutionManifest>,
+}
+
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CustomTypeDetails {
@@ -1289,10 +1677,36 @@ pub struct CustomTypeDetails {
pub properties: CustomTypeProperties,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub ddl: Option<CustomTypeDdl>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub oracle_metadata: Option<OracleTypeMetadata>,
}
#[cfg(test)]
mod tests {
+ #[test]
+ fn custom_type_details_accepts_old_pg_json_without_oracle_metadata() {
+ let old = serde_json::json!({
+ "name": "state", "schema": "public", "kind": "enum", "comment": null,
+ "members": [{"name": "", "dataType": "", "ordinal": 1, "enumValue": "ready"}],
+ "properties": {}, "ddl": {"sql": "CREATE TYPE state AS ENUM ('ready');", "complete": true}
+ });
+ let details: super::CustomTypeDetails = serde_json::from_value(old).unwrap();
+ assert!(details.oracle_metadata.is_none());
+ assert!(details.ddl.as_ref().unwrap().complete);
+ assert_eq!(details.members[0].enum_value.as_deref(), Some("ready"));
+ let serialized = serde_json::to_value(details).unwrap();
+ assert!(serialized.get("oracleMetadata").is_none());
+ for (kind, label) in [
+ (super::CustomTypeKind::Object, "object"),
+ (super::CustomTypeKind::Collection, "collection"),
+ (super::CustomTypeKind::Other, "other"),
+ ] {
+ assert_eq!(kind.as_str(), label);
+ assert_eq!(serde_json::to_value(kind).unwrap(), label);
+ assert_eq!(serde_json::from_value::<super::CustomTypeKind>(serde_json::json!(label)).unwrap(), kind);
+ }
+ }
+
#[test]
fn blob_bindings_refuse_edited_previews_and_invalid_later_parameters() {
let previews = vec!["first reviewed save".to_string(), "second reviewed save".to_string()];
diff --git a/crates/dbx-web/src/main.rs b/crates/dbx-web/src/main.rs
index 3cf5424c31..074007e37b 100644
--- a/crates/dbx-web/src/main.rs
+++ b/crates/dbx-web/src/main.rs
@@ -799,6 +799,13 @@ async fn serve() -> Result<(), String> {
.route("/schema/object-source", get(routes::schema::get_object_source))
.route("/schema/event-info", get(routes::schema::get_event_info))
.route("/schema/custom-type-details", get(routes::schema::get_custom_type_details))
+ .route("/schema/oracle-type-data", post(routes::schema::verify_oracle_type_data))
+ .route("/schema/oracle-type-evolution", post(routes::schema::prepare_oracle_type_evolution))
+ .route(
+ "/schema/oracle-type-management-snapshot",
+ get(routes::schema::get_oracle_type_management_snapshot)
+ .post(routes::schema::read_oracle_type_management_snapshot),
+ )
.route("/schema/columns", get(routes::schema::list_columns))
.route("/plugin/table-metadata", post(routes::schema::get_plugin_table_metadata))
.route("/schema/all-columns", get(routes::schema::get_all_columns))
@@ -900,6 +907,7 @@ async fn serve() -> Result<(), String> {
.route("/query/build-drop-schema-sql", post(routes::query::build_drop_schema_sql))
.route("/query/build-duplicate-table-structure-sql", post(routes::query::build_duplicate_table_structure_sql))
.route("/query/build-copy-table-data-sql", post(routes::query::build_copy_table_data_sql))
+ .route("/query/build-oracle-type-management-sql", post(routes::query::build_oracle_type_management_sql))
.route(
"/query/build-executable-object-source-statements",
post(routes::query::build_executable_object_source_statements),
diff --git a/crates/dbx-web/src/routes/query.rs b/crates/dbx-web/src/routes/query.rs
index 3856234023..56bafaaae5 100644
--- a/crates/dbx-web/src/routes/query.rs
+++ b/crates/dbx-web/src/routes/query.rs
@@ -36,6 +36,7 @@ pub struct ExecuteQueryRequest {
pub use_transaction: Option<bool>,
pub continue_on_error: Option<bool>,
pub execution_mode: Option<dbx_core::query::QueryExecutionMode>,
+ pub type_recovery: Option<dbx_core::storage::TypeRecoveryContext>,
/// MySQL auto-commit tabs: keep a transaction the user opened explicitly
/// (`BEGIN` / `START TRANSACTION`) open across executions until COMMIT /
/// ROLLBACK. Defaults to the historical cleanup when omitted.
@@ -47,6 +48,8 @@ pub struct ExecuteQueryRequest {
#[serde(rename_all = "camelCase")]
pub struct CancelRequest {
pub execution_id: String,
+ pub cancel: Option<bool>,
+ pub type_recovery: Option<dbx_core::storage::TypeExecutionBinding>,
}
const CONDITIONAL_UPDATE_CANCEL_WAIT: Duration = Duration::from_secs(10);
@@ -549,6 +552,22 @@ pub async fn execute_conditional_update(
.await?;
let execution_id = req.execution_id.unwrap_or_else(|| uuid::Uuid::new_v4().to_string());
+ let recovery = req.type_recovery.map(|context| dbx_core::storage::TypeExecutionBinding {
+ execution_id: execution_id.clone(),
+ context,
+ connection_id: req.connection_id.clone(),
+ database: database.clone(),
+ schema: req.schema.clone(),
+ sql: req.sql.clone(),
+ });
+ if let Some(binding) = &recovery {
+ state
+ .app
+ .storage
+ .claim_type_execution(binding)
+ .await
+ .map_err(|error| AppError::from(dbx_core::backend_error::BackendError::from_legacy_backend(&error)))?;
+ }
let registered = state.app.running_queries.register_task_for_terminal_confirmation(
execution_id.clone(),
RunningTaskMetadata::query(req.connection_id.clone(), database.clone(), req.client_session_id.clone()),
@@ -590,8 +609,10 @@ pub async fn execute_conditional_update(
},
)
.await;
- let _ = result_tx.send(result);
- drop(registered);
+ let result =
+ dbx_core::query_cancel::finish_conditional_update(registered, &app.storage, recovery.as_ref(), result)
+ .await;
+ let _ = result_tx.send(result.map_err(AppError::from));
});
let result = match response_timeout {
@@ -613,7 +634,7 @@ pub async fn execute_conditional_update(
Err(_) => return Err(AppError::internal("Conditional update execution task stopped unexpectedly")),
},
};
- result.map(Json).map_err(|error| AppError::from(error.into_backend_error()))
+ result.map(Json)
}
pub async fn execute_multi(
@@ -754,9 +775,42 @@ pub async fn cancel_query(
pub async fn cancel_conditional_update(
State(state): State<Arc<WebState>>,
+ headers: HeaderMap,
Json(req): Json<CancelRequest>,
-) -> Json<dbx_core::query_cancel::CancellationWaitResult> {
- Json(state.app.running_queries.cancel_and_wait(&req.execution_id, CONDITIONAL_UPDATE_CANCEL_WAIT).await)
+) -> Result<Json<dbx_core::query_cancel::CancellationWaitResult>, AppError> {
+ if let Some(binding) = req.type_recovery {
+ if req.cancel != Some(false) || binding.execution_id != req.execution_id {
+ return Err(AppError::from(
+ "TYPE recovery observation requires the original execution ID and cancel=false",
+ ));
+ }
+ let database = super::mcp_policy::ensure_sql(
+ &state,
+ &headers,
+ &binding.connection_id,
+ &binding.database,
+ &binding.sql,
+ false,
+ )
+ .await?;
+ if database != binding.database {
+ return Err(AppError::from("TYPE recovery cannot switch the original database"));
+ }
+ return dbx_core::query_cancel::observe_type_execution(
+ &state.app.storage,
+ &state.app.running_queries,
+ &binding,
+ CONDITIONAL_UPDATE_CANCEL_WAIT,
+ )
+ .await
+ .map(Json)
+ .map_err(AppError::from);
+ }
+ Ok(Json(if req.cancel == Some(false) {
+ state.app.running_queries.wait_for_completion(&req.execution_id, CONDITIONAL_UPDATE_CANCEL_WAIT).await
+ } else {
+ state.app.running_queries.cancel_and_wait(&req.execution_id, CONDITIONAL_UPDATE_CANCEL_WAIT).await
+ }))
}
pub async fn read_large_value_chunk(
@@ -1297,6 +1351,12 @@ pub async fn build_executable_object_source_statements(
dbx_core::object_source_sql::build_executable_object_source_statements(req.input).map(Json).map_err(AppError::from)
}
+pub async fn build_oracle_type_management_sql(
+ Json(input): Json<dbx_core::db::OracleTypeManagementSqlInput>,
+) -> Result<Json<dbx_core::db::OracleTypeManagementSqlResult>, AppError> {
+ dbx_core::schema::build_oracle_type_management_sql(input).map(Json).map_err(AppError::from)
+}
+
pub async fn validate_oracle_executable_object_source(
Json(req): Json<ValidateOracleExecutableObjectSourceRequest>,
) -> Result<Json<()>, AppError> {
@@ -1609,6 +1669,101 @@ mod tests {
(state, dir)
}
+ #[tokio::test]
+ async fn conditional_update_wait_only_preserves_the_running_statement_and_reads_completion() {
+ let (state, _dir) = test_web_state().await;
+ let registered = state
+ .app
+ .running_queries
+ .register_task_for_terminal_confirmation("type-step".to_string(), Default::default());
+ let token = registered.token();
+ let request = serde_json::from_value(serde_json::json!({"executionId":"type-step", "cancel":false})).unwrap();
+ let wait = cancel_conditional_update(AxumState(state), HeaderMap::new(), Json(request));
+ tokio::pin!(wait);
+ assert!(tokio::time::timeout(Duration::from_millis(5), &mut wait).await.is_err());
+ assert!(!token.is_cancelled());
+ registered.finish_with_database_result(&Ok::<_, dbx_core::query::QueryExecutionError>(()));
+ let result = wait.await.unwrap().0;
+ assert!(!result.requested && result.terminal);
+ assert_eq!(result.database_terminal, Some(true));
+ }
+
+ #[tokio::test]
+ async fn conditional_update_omitted_cancel_keeps_the_existing_cancellation_contract() {
+ let (state, _dir) = test_web_state().await;
+ let registered = state
+ .app
+ .running_queries
+ .register_task_for_terminal_confirmation("old-caller".to_string(), Default::default());
+ let token = registered.token();
+ let completion = tokio::spawn(async move {
+ token.cancelled().await;
+ drop(registered);
+ });
+ let request = serde_json::from_value(serde_json::json!({"executionId":"old-caller"})).unwrap();
+ let result = cancel_conditional_update(AxumState(state), HeaderMap::new(), Json(request)).await.unwrap().0;
+ completion.await.unwrap();
+ assert!(result.requested && result.terminal);
+ assert_eq!(result.database_terminal, Some(false));
+ }
+
+ #[tokio::test]
+ async fn duplicate_type_execution_is_unknown_and_does_not_replace_the_receipt() {
+ let (state, _dir) = test_web_state().await;
+ let binding = dbx_core::storage::TypeExecutionBinding {
+ execution_id: "type-duplicate".into(),
+ context: dbx_core::storage::TypeRecoveryContext { plan_id: "plan".into(), step_id: "step".into() },
+ connection_id: "original".into(),
+ database: "service".into(),
+ schema: Some("APP".into()),
+ sql: "CREATE TYPE APP.T AS OBJECT (ID NUMBER)".into(),
+ };
+ state.app.storage.claim_type_execution(&binding).await.unwrap();
+ let request = serde_json::from_value(serde_json::json!({
+ "executionId": binding.execution_id, "connectionId": binding.connection_id,
+ "database": binding.database, "schema": binding.schema, "sql": binding.sql,
+ "typeRecovery": { "planId": "plan", "stepId": "step" }
+ }))
+ .unwrap();
+ let error =
+ execute_conditional_update(AxumState(state.clone()), HeaderMap::new(), Json(request)).await.unwrap_err();
+ let envelope = serde_json::to_value(&error.error).unwrap();
+ assert_eq!(envelope["operationOutcome"], "unknown");
+ assert_eq!(envelope["code"], "DBX-LEGACY-0001");
+ assert_eq!(state.app.storage.type_execution_terminal(&binding).await.unwrap(), Some(false));
+ assert!(state.app.running_queries.diagnostics().active_execution_ids.is_empty());
+ }
+
+ #[tokio::test]
+ async fn type_observation_checks_binding_and_current_mcp_permissions() {
+ let (state, _dir) = test_web_state().await;
+ let binding = dbx_core::storage::TypeExecutionBinding {
+ execution_id: "type-observation".into(),
+ context: dbx_core::storage::TypeRecoveryContext { plan_id: "plan".into(), step_id: "step".into() },
+ connection_id: "original".into(),
+ database: "service".into(),
+ schema: Some("APP".into()),
+ sql: "CREATE TYPE APP.T AS OBJECT (ID NUMBER)".into(),
+ };
+ state.app.storage.claim_type_execution(&binding).await.unwrap();
+ state.app.storage.finish_type_execution(&binding).await.unwrap();
+ let request = || {
+ serde_json::from_value(
+ serde_json::json!({ "executionId": binding.execution_id, "cancel": false, "typeRecovery": binding }),
+ )
+ .unwrap()
+ };
+ let result =
+ cancel_conditional_update(AxumState(state.clone()), HeaderMap::new(), Json(request())).await.unwrap().0;
+ assert_eq!(result.database_terminal, Some(true));
+ let mut mismatched: CancelRequest = request();
+ mismatched.type_recovery.as_mut().unwrap().sql.push(';');
+ assert!(cancel_conditional_update(AxumState(state.clone()), HeaderMap::new(), Json(mismatched)).await.is_err());
+ let mut headers = HeaderMap::new();
+ headers.insert("x-dbx-mcp-request", HeaderValue::from_static("1"));
+ assert!(cancel_conditional_update(AxumState(state), headers, Json(request())).await.is_err());
+ }
+
fn deploy_result(status: &str, statement_count: usize) -> dbx_core::query::SchemaDiffDeployResult {
dbx_core::query::SchemaDiffDeployResult {
transaction_id: "deploy-test".to_string(),
diff --git a/crates/dbx-web/src/routes/schema.rs b/crates/dbx-web/src/routes/schema.rs
index b963693623..b54897ceaa 100644
--- a/crates/dbx-web/src/routes/schema.rs
+++ b/crates/dbx-web/src/routes/schema.rs
@@ -461,6 +461,54 @@ pub async fn get_custom_type_details(
Ok(Json(result))
}
+pub async fn verify_oracle_type_data(
+ State(state): State<Arc<WebState>>,
+ Json(input): Json<dbx_core::db::OracleTypeDataRequest>,
+) -> Result<Json<dbx_core::db::OracleTypeDataResult>, AppError> {
+ Ok(Json(dbx_core::schema::verify_oracle_type_data_core(&state.app, input).await?))
+}
+
+pub async fn prepare_oracle_type_evolution(
+ State(state): State<Arc<WebState>>,
+ Json(input): Json<dbx_core::db::OracleTypeEvolutionRequest>,
+) -> Result<Json<dbx_core::db::OracleTypeEvolutionManifest>, AppError> {
+ Ok(Json(dbx_core::schema::prepare_oracle_type_evolution_core(&state.app, input).await?))
+}
+
+pub async fn get_oracle_type_management_snapshot(
+ State(state): State<Arc<WebState>>,
+ Query(q): Query<SchemaQuery>,
+) -> Result<Json<dbx_core::db::OracleTypeManagementSnapshot>, AppError> {
+ let result = dbx_core::schema::get_oracle_type_management_snapshot_core(
+ &state.app,
+ &q.connection_id,
+ q.database.as_deref().unwrap_or(""),
+ q.schema.as_deref().unwrap_or(""),
+ q.table.as_deref().unwrap_or(""),
+ )
+ .await
+ .map_err(AppError::from)?;
+ Ok(Json(result))
+}
+
+pub async fn read_oracle_type_management_snapshot(
+ State(state): State<Arc<WebState>>,
+ Json(request): Json<dbx_core::db::OracleTypeManagementSnapshotRequest>,
+) -> Result<Json<dbx_core::db::OracleTypeManagementSnapshot>, AppError> {
+ let target = request.target;
+ let result = dbx_core::schema::get_oracle_type_management_snapshot_with_objects_core(
+ &state.app,
+ &target.connection_id,
+ &target.database,
+ &target.owner,
+ &target.name,
+ &request.known_objects,
+ )
+ .await
+ .map_err(AppError::from)?;
+ Ok(Json(result))
+}
+
pub(crate) use dbx_core::object_cache::object_metadata_cache_prefix;
use dbx_core::object_cache::{metadata_cache_segment, OBJECT_METADATA_CACHE_PREFIX};
diff --git a/docs/content/docs/object-browser.cn.mdx b/docs/content/docs/object-browser.cn.mdx
index a8d9d68f5b..42805e577b 100644
--- a/docs/content/docs/object-browser.cn.mdx
+++ b/docs/content/docs/object-browser.cn.mdx
@@ -38,6 +38,7 @@ description: 使用列表或网格集中查看数据库对象、统计信息、
- 表和视图数据
- 表结构、字段、索引、外键、触发器和 DDL
- 视图、过程、函数、触发器等对象源码
+- Oracle、OceanBase Oracle、Dameng 的 TYPE 详情和只读 TYPE/TYPE BODY 源码
- 数据库专属管理界面
上下文菜单还可以提供:
@@ -86,11 +87,16 @@ Schema 索引只在索引分组或**索引**筛选中按页加载,不混入**
## DDL 与源码
- **查看 DDL**优先读取数据库或驱动提供的定义
-- **对象源码**用于视图、过程、函数、触发器和其他可编辑对象
+- **对象源码**用于视图、过程、函数、触发器等对象;Oracle、OceanBase Oracle、Dameng 的 TYPE/TYPE BODY 源码为只读
+- 在这三种数据库中,打开 TYPE 行可查看属性、方法、集合信息、状态和当前可见的 TYPE BODY 配对;使用“源码”标签查看或复制定义
+- 若列表中存在 TYPE BODY,可单独打开该行查看源码;它与同名 TYPE 分开读取
- 源码视图支持搜索;数据库和对象允许时,可以打开到编辑器修改
- 保存源码或执行 DDL 前会进入只读、生产保护和危险操作检查
DBX 显示的是当前驱动能获取到的定义。格式、是否包含权限/注释/存储属性,以及能否直接编辑,都会因数据库而异。
+元数据区域会标明信息不完整、不可用或不支持;只有成功读取的空区域才会显示为空。
+
+通过通用 JDBC 连接 OceanBase Oracle 模式时,使用显式 `jdbc:oceanbase:oracle://` URL,使类型列表、详情和源码采用一致的方言。普通 `jdbc:oceanbase://` URL 不会据此推断为 Oracle 模式。
## 与对象树的区别
diff --git a/docs/content/docs/object-browser.mdx b/docs/content/docs/object-browser.mdx
index 69183698fa..eed5ada3ca 100644
--- a/docs/content/docs/object-browser.mdx
+++ b/docs/content/docs/object-browser.mdx
@@ -38,6 +38,7 @@ Click or double-click an object to open a type-appropriate view:
- Table or view data
- Table structure, columns, indexes, foreign keys, triggers, and DDL
- Source for views, procedures, functions, triggers, and other objects
+- Oracle, OceanBase Oracle, and Dameng TYPE details and read-only TYPE/TYPE BODY source
- Database-specific administration interfaces
Context menus can also provide:
@@ -86,11 +87,16 @@ Use checkboxes to select multiple objects. Depending on the database, bulk actio
## DDL and Source
- **View DDL** prefers definitions returned by the database or driver
-- **Object source** covers views, procedures, functions, triggers, and other editable objects
+- **Object source** covers views, procedures, functions, triggers, and other objects; Oracle, OceanBase Oracle, and Dameng TYPE/TYPE BODY source is read-only
+- In those three databases, open a TYPE row for its attributes, methods, collection details, status, and visible TYPE BODY pairing; use the Source tab to read or copy its definition
+- When a TYPE BODY is listed, open that row to read its source separately from the same-named TYPE
- Source views support search and can open in the editor when the database and object allow it
- Saving source or executing DDL passes through read-only, production, and dangerous-operation checks
DBX shows the definition available from the active driver. Formatting, privileges/comments/storage properties, and direct edit support vary by database.
+Metadata sections identify incomplete, unavailable, or unsupported dictionary reads; only a successfully read empty section is presented as empty.
+
+For OceanBase Oracle mode over generic JDBC, use an explicit `jdbc:oceanbase:oracle://` URL so type listing, details, and source use the same dialect. A plain `jdbc:oceanbase://` URL does not identify Oracle mode.
## Object Tree vs. Object Browser
diff --git a/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java b/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java
index b9a51858dc..e66bf99e97 100644
--- a/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java
+++ b/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java
@@ -184,6 +184,7 @@ public final class DbxJdbcPlugin {
new JdbcDriverQuirkRule("jdbc:oracle:", ORACLE_QUIRKS),
new JdbcDriverQuirkRule("jdbc:oceanbase:oracle://", ORACLE_QUIRKS),
new JdbcDriverQuirkRule("jdbc:dm:", ORACLE_QUIRKS),
+ new JdbcDriverQuirkRule("jdbc:oceanbase:oracle://", ORACLE_QUIRKS),
new JdbcDriverQuirkRule("jdbc:taos:", TAOS_QUIRKS),
new JdbcDriverQuirkRule("jdbc:taos-ws:", TAOS_QUIRKS),
new JdbcDriverQuirkRule("jdbc:taos-rs:", TAOS_QUIRKS)
@@ -2786,6 +2787,16 @@ public final class DbxJdbcPlugin {
if (indexes) {
appendOracleSchemaIndexes(conn, owner, objects);
}
+ if (types.isEmpty() || types.contains("TYPE") || types.contains("TYPE_BODY")) {
+ String typeOwner = schema != null ? schema : conn.getMetaData().getUserName();
+ try {
+ oracleAppendTypeObjects(conn, typeOwner, objects);
+ } catch (SQLException error) {
+ // Preserve the existing best-effort broad catalog/JDBC fallback.
+ // Explicit type-group requests must report an unreadable catalog.
+ if (!types.isEmpty()) throw error;
+ }
+ }
return filterMetadataNodes(
objects,
filter,
@@ -5024,6 +5035,25 @@ public final class DbxJdbcPlugin {
return result;
}
+ private static void oracleAppendTypeObjects(Connection conn, String owner, ArrayNode result) throws SQLException {
+ String sql =
+ "SELECT object_name AS name, CASE object_type WHEN 'TYPE BODY' THEN 'TYPE_BODY' ELSE object_type END AS object_type " +
+ "FROM all_objects WHERE owner = ? AND object_type IN ('TYPE', 'TYPE BODY') ORDER BY object_type, object_name";
+ try (PreparedStatement ps = conn.prepareStatement(sql)) {
+ ps.setString(1, owner);
+ try (ResultSet rs = ps.executeQuery()) {
+ while (rs.next()) {
+ ObjectNode item = MAPPER.createObjectNode();
+ item.put("name", rs.getString("name"));
+ item.put("object_type", rs.getString("object_type"));
+ putNullable(item, "schema", owner);
+ item.putNull("comment");
+ result.add(item);
+ }
+ }
+ }
+ }
+
private static JsonNode oracleListIndexes(Connection conn, String owner, String table) throws SQLException {
return oracleListIndexes(conn, owner, table, false);
}
@@ -5147,8 +5177,12 @@ public final class DbxJdbcPlugin {
throws SQLException {
Connection conn = openConnection(connection);
if (driverQuirks(connection).useOracleMetadata()) {
- String owner = exactIdentity ? schema : oracleEffectiveSchema(conn, schema);
String metadataType = oracleMetadataObjectType(objectType);
+ if ("TYPE".equals(metadataType) || "TYPE_BODY".equals(metadataType)) {
+ String owner = schema != null ? schema : conn.getMetaData().getUserName();
+ return oracleTypeSource(conn, owner, name, metadataType);
+ }
+ String owner = exactIdentity ? schema : oracleEffectiveSchema(conn, schema);
String sql = "SELECT DBMS_METADATA.GET_DDL(?, ?, ?) FROM DUAL";
try (PreparedStatement ps = conn.prepareStatement(sql)) {
ps.setString(1, metadataType);
@@ -5240,6 +5274,51 @@ public final class DbxJdbcPlugin {
throw new SQLException("Object source is not supported by this JDBC driver");
}
+ private static JsonNode oracleTypeSource(Connection conn, String owner, String name, String objectType) throws SQLException {
+ String source = null;
+ SQLException ddlError = null;
+ try (PreparedStatement ps = conn.prepareStatement("SELECT DBMS_METADATA.GET_DDL(?, ?, ?) FROM DUAL")) {
+ ps.setString(1, objectType);
+ ps.setString(2, name);
+ ps.setString(3, owner);
+ try (ResultSet rs = ps.executeQuery()) {
+ if (rs.next()) source = rs.getString(1);
+ }
+ } catch (SQLException error) {
+ ddlError = error;
+ }
+ if (source == null || source.isBlank()) {
+ StringBuilder text = new StringBuilder();
+ try (PreparedStatement ps = conn.prepareStatement(
+ "SELECT text FROM all_source WHERE owner = ? AND name = ? AND type = ? ORDER BY line"
+ )) {
+ ps.setString(1, owner);
+ ps.setString(2, name);
+ ps.setString(3, objectType.replace('_', ' '));
+ try (ResultSet rs = ps.executeQuery()) {
+ while (rs.next()) {
+ String line = rs.getString(1);
+ if (line == null) continue;
+ if (!text.isEmpty() && text.charAt(text.length() - 1) != '\n' && text.charAt(text.length() - 1) != '\r') text.append('\n');
+ text.append(line);
+ }
+ }
+ } catch (SQLException error) {
+ if (ddlError != null) error.addSuppressed(ddlError);
+ throw error;
+ }
+ source = text.toString();
+ }
+ if (source.isBlank()) throw new SQLException("Complete type source is unavailable", ddlError);
+ ObjectNode item = MAPPER.createObjectNode();
+ item.put("name", name);
+ item.put("object_type", objectType);
+ putNullable(item, "schema", owner);
+ item.put("source", source);
+ item.put("editable", false);
+ return item;
+ }
+
/**
* Generic JDBC does not define a routine DDL API. Return the structured
* parameter metadata that it does define and leave source empty/read-only.
diff --git a/plugins/jdbc/src/test/java/app/dbx/jdbc/OracleTypeMetadataTest.java b/plugins/jdbc/src/test/java/app/dbx/jdbc/OracleTypeMetadataTest.java
new file mode 100644
index 0000000000..58547acd7c
--- /dev/null
+++ b/plugins/jdbc/src/test/java/app/dbx/jdbc/OracleTypeMetadataTest.java
@@ -0,0 +1,314 @@
+package app.dbx.jdbc;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.Driver;
+import java.sql.DriverManager;
+import java.sql.DriverPropertyInfo;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.util.Properties;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+final class OracleTypeMetadataTest {
+ private static final ObjectMapper MAPPER = new ObjectMapper();
+ private static final String OWNER = "Mixed Owner";
+ private static final String NAME = "Mixed Type";
+
+ @Test
+ void listsTypesAndBodiesThroughTheRpcWithExactOwnerAndPaging() throws Exception {
+ for (String dialect : new String[] { "oracle", "dm", "oceanbase-oracle" }) {
+ try (Fixture fixture = new Fixture(dialect)) {
+ fixture.object(OWNER, NAME, "TYPE");
+ fixture.object(OWNER, NAME, "TYPE BODY");
+ fixture.object(OWNER.toUpperCase(), "Wrong owner", "TYPE");
+ fixture.object(OWNER, "Unrelated", "PACKAGE");
+
+ JsonNode all = fixture.list(OWNER, "TYPE", "TYPE_BODY");
+ assertFalse(all.has("error"), all.toString());
+ assertEquals(2, all.path("result").size());
+ assertEquals("TYPE", all.path("result").path(0).path("object_type").asText());
+ assertEquals("TYPE_BODY", all.path("result").path(1).path("object_type").asText());
+ assertEquals(NAME, all.path("result").path(1).path("name").asText());
+ assertEquals(OWNER, all.path("result").path(1).path("schema").asText());
+
+ ObjectNode page = fixture.params(OWNER);
+ page.putArray("object_types").add("TYPE").add("TYPE_BODY");
+ page.put("filter", "Mixed");
+ page.put("offset", 1);
+ page.put("limit", 1);
+ JsonNode paged = fixture.request("listObjects", page);
+ assertFalse(paged.has("error"), paged.toString());
+ assertEquals(1, paged.path("result").size());
+ assertEquals("TYPE_BODY", paged.path("result").path(0).path("object_type").asText());
+ }
+ }
+ }
+
+ @Test
+ void doesNotResolveMissingQuotedTypeOwnersToUppercase() throws Exception {
+ try (Fixture fixture = new Fixture("oracle")) {
+ fixture.object(OWNER.toUpperCase(), NAME, "TYPE");
+ fixture.ddl(OWNER.toUpperCase(), NAME, "TYPE", "upper owner source");
+ JsonNode listed = fixture.list(OWNER, "TYPE");
+ assertFalse(listed.has("error"), listed.toString());
+ assertEquals(0, listed.path("result").size());
+ assertTrue(fixture.source(OWNER, NAME, "TYPE").has("error"));
+ }
+ }
+
+ @Test
+ void reportsTypeCatalogFailureWithoutBreakingTableOnlyFallback() throws Exception {
+ try (Fixture fixture = new Fixture("oracle")) {
+ fixture.catalog.createStatement().execute("DROP TABLE all_objects");
+ fixture.catalog.createStatement().execute("CREATE TABLE sample_table(id INT)");
+ assertTrue(fixture.list(OWNER, "TYPE").has("error"));
+ fixture.catalog.createStatement().execute("DROP TABLE all_tab_comments");
+ JsonNode tables = fixture.list("PUBLIC", "TABLE");
+ assertFalse(tables.has("error"), tables.toString());
+ boolean found = false;
+ for (JsonNode table : tables.path("result")) {
+ found |= "SAMPLE_TABLE".equals(table.path("name").asText());
+ }
+ assertTrue(found);
+ }
+ }
+
+ @Test
+ void readsCompleteTypeAndBodyClobsAsReadonlyWithoutMixingKinds() throws Exception {
+ for (String dialect : new String[] { "oracle", "oceanbase-oracle" }) {
+ try (Fixture fixture = new Fixture(dialect)) {
+ String body = "CREATE TYPE BODY \"Mixed Type\" AS\n" + "-- long body\n".repeat(8000) + "END;";
+ fixture.ddl(OWNER, NAME, "TYPE", "CREATE TYPE \"Mixed Type\" AS OBJECT(id NUMBER)");
+ fixture.ddl(OWNER, NAME, "TYPE_BODY", body);
+ JsonNode type = fixture.source(OWNER, NAME, "TYPE");
+ JsonNode result = fixture.source(OWNER, NAME, "TYPE BODY");
+ assertFalse(type.has("error"), type.toString());
+ assertFalse(result.has("error"), result.toString());
+ assertFalse(type.path("result").path("editable").asBoolean(true));
+ assertFalse(result.path("result").path("editable").asBoolean(true));
+ assertEquals(body, result.path("result").path("source").asText());
+ assertFalse(type.path("result").path("source").asText().contains("BODY"));
+ }
+ }
+ }
+
+ @Test
+ void fallsBackFromNullEmptyOrBlankDdlToOrderedExactTypeSource() throws Exception {
+ for (String ddl : new String[] { null, "", " \n" }) {
+ for (String kind : new String[] { "TYPE", "TYPE_BODY" }) {
+ for (String dialect : new String[] { "dm", "oceanbase-oracle" }) {
+ try (Fixture fixture = new Fixture(dialect)) {
+ String dictionaryKind = kind.replace('_', ' ');
+ fixture.ddl(OWNER, NAME, kind, ddl);
+ fixture.line(OWNER, NAME, dictionaryKind, 2, "END;\n");
+ fixture.line(OWNER, NAME, dictionaryKind, 1, dictionaryKind + " \"Mixed Type\" AS\n");
+ fixture.line(OWNER, NAME, kind.equals("TYPE") ? "TYPE BODY" : "TYPE", 1, "WRONG KIND");
+ fixture.line(OWNER.toUpperCase(), NAME, dictionaryKind, 1, "WRONG OWNER");
+ JsonNode source = fixture.source(OWNER, NAME, kind);
+ assertFalse(source.has("error"), source.toString());
+ assertEquals(dictionaryKind + " \"Mixed Type\" AS\nEND;\n", source.path("result").path("source").asText());
+ assertFalse(source.path("result").path("editable").asBoolean(true));
+ }
+ }
+ }
+ }
+ }
+
+ @Test
+ void doesNotApplyOracleTypeMetadataToOrdinaryOceanBaseOrMysqlUrls() throws Exception {
+ for (String dialect : new String[] { "oceanbase", "mysql" }) {
+ try (Fixture fixture = new Fixture(dialect)) {
+ fixture.object(OWNER, NAME, "TYPE");
+ fixture.ddl(OWNER, NAME, "TYPE", "CREATE TYPE should_not_be_read");
+ JsonNode listed = fixture.list(OWNER, "TYPE", "TYPE_BODY");
+ assertFalse(listed.has("error"), listed.toString());
+ assertEquals(0, listed.path("result").size());
+ assertTrue(fixture.source(OWNER, NAME, "TYPE").has("error"));
+ }
+ }
+ }
+
+ @Test
+ void explicitOceanbaseOracleModeKeepsSchemaDiscoveryAndSqlPageBoundaries() throws Exception {
+ try (Fixture fixture = new Fixture("oceanbase-oracle")) {
+ JsonNode schemas = fixture.request("listSchemas", fixture.params(null));
+ assertFalse(schemas.has("error"), schemas.toString());
+ assertEquals(OWNER.toUpperCase(), schemas.path("result").path(0).asText());
+ assertEquals(0, fixture.request("listDatabases", fixture.params(null)).path("result").size());
+
+ ObjectNode query = fixture.params(null).put("database", "APP").put("maxRows", 2);
+ query.put("sql", "SELECT X FROM SYSTEM_RANGE(1, 5) ORDER BY X");
+ JsonNode first = fixture.request("executeQuery", query);
+ assertFalse(first.has("error"), first.toString());
+ assertEquals(2, first.path("result").path("rows").size());
+ assertTrue(first.path("result").path("truncated").asBoolean());
+ query.put("sql", "SELECT X FROM (SELECT X, ROWNUM rn FROM (SELECT X FROM SYSTEM_RANGE(1, 5) ORDER BY X)) WHERE rn > 2 AND rn <= 4");
+ JsonNode second = fixture.request("executeQuery", query);
+ assertFalse(second.has("error"), second.toString());
+ assertEquals(3, second.path("result").path("rows").path(0).path(0).asInt());
+ assertEquals(4, second.path("result").path("rows").path(1).path(0).asInt());
+ assertFalse(second.path("result").path("truncated").asBoolean());
+ }
+ }
+
+ @Test
+ void fallsBackAfterDdlFailureButReportsMissingOrFailedSource() throws Exception {
+ try (Fixture fixture = new Fixture("oracle")) {
+ fixture.catalog.createStatement().execute("DROP TABLE type_ddl");
+ String full = "TYPE BODY \"Mixed Type\" AS\n" + "-- source\n".repeat(8000) + "END;";
+ fixture.line(OWNER, NAME, "TYPE BODY", 1, full);
+ JsonNode source = fixture.source(OWNER, NAME, "TYPE_BODY");
+ assertFalse(source.has("error"), source.toString());
+ assertEquals(full, source.path("result").path("source").asText());
+ assertTrue(fixture.source(OWNER, NAME, "TYPE").has("error"));
+ fixture.catalog.createStatement().execute("DROP TABLE all_source");
+ assertTrue(fixture.source(OWNER, NAME, "TYPE_BODY").has("error"));
+ }
+ }
+
+ @Test
+ void preservesRoutineOwnerResolutionAndSourceContract() throws Exception {
+ try (Fixture fixture = new Fixture("oracle")) {
+ fixture.ddl(OWNER.toUpperCase(), "PROC", "PROCEDURE", "CREATE PROCEDURE PROC AS BEGIN NULL; END;");
+ JsonNode source = fixture.source(OWNER, "PROC", "PROCEDURE");
+ assertFalse(source.has("error"), source.toString());
+ assertEquals(OWNER.toUpperCase(), source.path("result").path("schema").asText());
+ assertFalse(source.path("result").has("editable"));
+ }
+ }
+
+ private static final class Fixture implements AutoCloseable, Driver {
+ private final String url;
+ private final String h2Url;
+ private final ObjectNode connection;
+ final Connection catalog;
+
+ Fixture(String dialect) throws Exception {
+ String id = UUID.randomUUID().toString().replace("-", "");
+ url = switch (dialect) {
+ case "oceanbase-oracle" -> "jdbc:oceanbase:oracle://localhost/dbx-types-" + id;
+ case "oceanbase" -> "jdbc:oceanbase://localhost/dbx-types-" + id;
+ default -> "jdbc:" + dialect + ":dbx-types:" + id;
+ };
+ h2Url = "jdbc:h2:mem:dbx_types_" + id;
+ catalog = DriverManager.getConnection(h2Url, "sa", "");
+ try (var statement = catalog.createStatement()) {
+ statement.execute("CREATE TABLE all_users(username VARCHAR(128))");
+ statement.execute("CREATE TABLE all_objects(owner VARCHAR(128), object_name VARCHAR(128), object_type VARCHAR(32))");
+ statement.execute("CREATE TABLE all_tab_comments(owner VARCHAR(128), table_name VARCHAR(128), table_type VARCHAR(32), comments VARCHAR(128))");
+ statement.execute("CREATE TABLE all_procedures(owner VARCHAR(128), object_name VARCHAR(128), object_type VARCHAR(32), procedure_name VARCHAR(128))");
+ statement.execute("CREATE TABLE all_sequences(sequence_owner VARCHAR(128), sequence_name VARCHAR(128))");
+ statement.execute("CREATE TABLE all_synonyms(owner VARCHAR(128), synonym_name VARCHAR(128))");
+ statement.execute("CREATE TABLE all_source(owner VARCHAR(128), name VARCHAR(128), type VARCHAR(32), line INT, text CLOB)");
+ statement.execute("CREATE TABLE type_ddl(ddl_owner VARCHAR(128), ddl_name VARCHAR(128), ddl_type VARCHAR(32), source CLOB)");
+ }
+ try (PreparedStatement ps = catalog.prepareStatement("INSERT INTO all_users VALUES (?)")) {
+ ps.setString(1, OWNER.toUpperCase());
+ ps.executeUpdate();
+ }
+ connection = MAPPER.createObjectNode().put("connection_string", url).put("username", "sa");
+ DriverManager.registerDriver(this);
+ }
+
+ void object(String owner, String name, String type) throws SQLException {
+ try (PreparedStatement ps = catalog.prepareStatement("INSERT INTO all_objects VALUES (?, ?, ?)")) {
+ ps.setString(1, owner);
+ ps.setString(2, name);
+ ps.setString(3, type);
+ ps.executeUpdate();
+ }
+ }
+
+ void ddl(String owner, String name, String type, String source) throws SQLException {
+ try (PreparedStatement ps = catalog.prepareStatement("INSERT INTO type_ddl VALUES (?, ?, ?, ?)")) {
+ ps.setString(1, owner);
+ ps.setString(2, name);
+ ps.setString(3, type);
+ ps.setString(4, source);
+ ps.executeUpdate();
+ }
+ }
+
+ void line(String owner, String name, String type, int line, String text) throws SQLException {
+ try (PreparedStatement ps = catalog.prepareStatement("INSERT INTO all_source VALUES (?, ?, ?, ?, ?)")) {
+ ps.setString(1, owner);
+ ps.setString(2, name);
+ ps.setString(3, type);
+ ps.setInt(4, line);
+ ps.setString(5, text);
+ ps.executeUpdate();
+ }
+ }
+
+ ObjectNode params(String schema) {
+ ObjectNode params = MAPPER.createObjectNode();
+ params.set("connection", connection);
+ params.put("schema", schema);
+ return params;
+ }
+
+ JsonNode list(String schema, String... kinds) throws Exception {
+ ObjectNode params = params(schema);
+ var types = params.putArray("object_types");
+ for (String kind : kinds) types.add(kind);
+ return request("listObjects", params);
+ }
+
+ JsonNode source(String schema, String name, String type) throws Exception {
+ return request("getObjectSource", params(schema).put("name", name).put("object_type", type));
+ }
+
+ JsonNode request(String method, JsonNode params) throws Exception {
+ Method handle = DbxJdbcPlugin.class.getDeclaredMethod("handleLine", String.class);
+ handle.setAccessible(true);
+ ObjectNode request = MAPPER.createObjectNode().put("id", 1).put("method", method);
+ request.set("params", params);
+ return MAPPER.valueToTree(handle.invoke(null, request.toString()));
+ }
+
+ @Override
+ public Connection connect(String candidate, Properties properties) throws SQLException {
+ if (!acceptsURL(candidate)) return null;
+ Connection delegate = DriverManager.getConnection(h2Url, "sa", "");
+ return (Connection) Proxy.newProxyInstance(getClass().getClassLoader(), new Class<?>[] { Connection.class }, (proxy, method, args) -> {
+ if (method.getName().equals("prepareStatement") && args[0].equals("SELECT DBMS_METADATA.GET_DDL(?, ?, ?) FROM DUAL")) {
+ return delegate.prepareStatement("SELECT source FROM type_ddl WHERE ddl_type = ? AND ddl_name = ? AND ddl_owner = ?");
+ }
+ try {
+ return method.invoke(delegate, args);
+ } catch (InvocationTargetException e) {
+ throw e.getCause();
+ }
+ });
+ }
+
+ @Override public boolean acceptsURL(String candidate) { return url.equals(candidate); }
+ @Override public DriverPropertyInfo[] getPropertyInfo(String candidate, Properties properties) { return new DriverPropertyInfo[0]; }
+ @Override public int getMajorVersion() { return 1; }
+ @Override public int getMinorVersion() { return 0; }
+ @Override public boolean jdbcCompliant() { return false; }
+ @Override public java.util.logging.Logger getParentLogger() { return java.util.logging.Logger.getGlobal(); }
+
+ @Override
+ public void close() throws Exception {
+ try {
+ request("close", params(null));
+ } finally {
+ DriverManager.deregisterDriver(this);
+ catalog.close();
+ }
+ }
+ }
+}
diff --git a/src-tauri/src/commands/query.rs b/src-tauri/src/commands/query.rs
index 372ad308ef..9870654ced 100644
--- a/src-tauri/src/commands/query.rs
+++ b/src-tauri/src/commands/query.rs
@@ -133,9 +133,22 @@ pub async fn execute_conditional_update(
client_session_id: Option<String>,
timeout_secs: Option<u64>,
execution_mode: Option<dbx_core::query::QueryExecutionMode>,
+ type_recovery: Option<dbx_core::storage::TypeRecoveryContext>,
) -> Result<db::QueryResult, BackendError> {
let execution_id =
execution_id.filter(|id| !id.trim().is_empty()).unwrap_or_else(|| uuid::Uuid::new_v4().to_string());
+ let recovery = type_recovery.map(|context| dbx_core::storage::TypeExecutionBinding {
+ execution_id: execution_id.clone(),
+ context,
+ connection_id: connection_id.clone(),
+ database: database.clone(),
+ schema: schema.clone(),
+ sql: sql.clone(),
+ });
+ if let Some(binding) = &recovery {
+ state.storage.claim_type_execution(binding).await.map_err(|error| BackendError::from_legacy_backend(&error))?;
+ }
+ let durable_recovery = recovery.is_some();
let registered = state.running_queries.register_task_for_terminal_confirmation(
execution_id.clone(),
RunningTaskMetadata::query(connection_id.clone(), database.clone(), client_session_id.clone()),
@@ -169,31 +182,44 @@ pub async fn execute_conditional_update(
},
)
.await;
+ let result = dbx_core::query_cancel::finish_conditional_update(
+ registered,
+ &app_state.storage,
+ recovery.as_ref(),
+ result,
+ )
+ .await;
let _ = result_tx.send(result);
- drop(registered);
});
- let result = match response_timeout {
+ match response_timeout {
Some(timeout) => match tokio::time::timeout(timeout, result_rx).await {
Ok(Ok(result)) => result,
Ok(Err(_)) => {
- return Err(BackendError::from_sql_detail("Conditional update execution task stopped unexpectedly"));
- }
- Err(_) => {
- return Err(BackendError::from_timeout_detail(&format!(
- "Query timed out after {} seconds",
- timeout.as_secs().max(1)
- )));
+ let message = "Conditional update execution task stopped unexpectedly";
+ Err(if durable_recovery {
+ BackendError::from_legacy_backend(message)
+ } else {
+ BackendError::from_sql_detail(message)
+ })
}
+ Err(_) => Err(BackendError::from_timeout_detail(&format!(
+ "Query timed out after {} seconds",
+ timeout.as_secs().max(1)
+ ))),
},
None => match result_rx.await {
Ok(result) => result,
Err(_) => {
- return Err(BackendError::from_sql_detail("Conditional update execution task stopped unexpectedly"));
+ let message = "Conditional update execution task stopped unexpectedly";
+ Err(if durable_recovery {
+ BackendError::from_legacy_backend(message)
+ } else {
+ BackendError::from_sql_detail(message)
+ })
}
},
- };
- result.map_err(dbx_core::query::QueryExecutionError::into_backend_error)
+ }
}
#[tauri::command]
@@ -328,8 +354,26 @@ pub async fn cancel_query(state: State<'_, Arc<AppState>>, execution_id: String)
pub async fn cancel_conditional_update(
state: State<'_, Arc<AppState>>,
execution_id: String,
+ cancel: Option<bool>,
+ type_recovery: Option<dbx_core::storage::TypeExecutionBinding>,
) -> Result<dbx_core::query_cancel::CancellationWaitResult, String> {
- Ok(state.running_queries.cancel_and_wait(&execution_id, Duration::from_secs(10)).await)
+ if let Some(binding) = type_recovery {
+ if cancel != Some(false) || binding.execution_id != execution_id {
+ return Err("TYPE recovery observation requires the original execution ID and cancel=false".into());
+ }
+ return dbx_core::query_cancel::observe_type_execution(
+ &state.storage,
+ &state.running_queries,
+ &binding,
+ Duration::from_secs(10),
+ )
+ .await;
+ }
+ Ok(if cancel == Some(false) {
+ state.running_queries.wait_for_completion(&execution_id, Duration::from_secs(10)).await
+ } else {
+ state.running_queries.cancel_and_wait(&execution_id, Duration::from_secs(10)).await
+ })
}
#[tauri::command]