25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
import * as api from "@/lib/backend/api";
import { BackendErrorException, formatError, normalizeBackendError } from "@/lib/backend/errorUtils";
import { connectionConfigFingerprint } from "@/lib/connection/connectionDatabaseInfo";
import { exactOracleTriggerMetadata } from "@/lib/database/oracleTriggerIdentity";
import { buildOracleCompileSql, oracleCompileUnsupportedReason } from "@/lib/database/oracleInvalidObjects";
import { buildTriggerToggleSql } from "@/lib/database/triggerToggleSql";
import { oracleTriggerDefinitionScopes, oracleTriggerSourceBinding, type OracleTriggerSqlBinding, type PreparedOracleTriggerSql, type OracleTriggerDatabaseType } from "@/lib/database/oracleTriggerSql";
import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
import { assertSourceIdentity, captureSourceIdentity, freezeSourceIdentities, renewSourceIdentity, type SourceIdentitySnapshot } from "@/lib/table/objectSourceIdentity";
import { inspectExactOracleTriggerSource } from "@/lib/table/objectSourceLoad";
import { invalidateObjectMetadataFacet } from "@/lib/metadata/objectMetadataCache";
import { invalidateObjectDdl } from "@/lib/metadata/objectDdlCache";
import { useConnectionStore } from "@/stores/connectionStore";
import { useSettingsStore } from "@/stores/settingsStore";
import { queryTimeoutSecsForConnection } from "@/lib/sql/queryTimeout";
import type { ObjectSource, OracleTriggerMetadata, QueryResult } from "@/types/database";
import type { OracleTriggerStructurePlan } from "./oracleTriggerStructurePlan";
import type { OracleTriggerStructureOperation } from "@/lib/table/tableStructureEditorSql";
export interface OracleTriggerTarget {
connectionId: string;
database: string;
catalog?: string;
owner: string;
name: string;
/** Separate from the trigger owner and the owning table/view's owner. */
executionSchema: string;
}
export interface OracleTriggerSnapshot {
target: Readonly<OracleTriggerTarget>;
raw: Readonly<ObjectSource>;
metadata: Readonly<OracleTriggerMetadata>;
identity: Readonly<SourceIdentitySnapshot>;
exists: boolean;
}
export type OracleTriggerAction = "enable" | "disable" | "compile" | "create" | "replace" | "delete";
export interface OracleTriggerStep {
action: OracleTriggerAction;
sql: string;
}
export interface OracleTriggerPlan {
target: Readonly<OracleTriggerTarget>;
action: OracleTriggerAction;
before: OracleTriggerSnapshot;
expectedEnabled?: boolean;
expectedAfter?: Readonly<{
binding: Readonly<OracleTriggerSqlBinding>;
proof: readonly string[];
definition: string;
comparisonSource: string;
}>;
parentBefore?: readonly string[];
steps: readonly Readonly<OracleTriggerStep>[];
}
export interface OracleTriggerStepResult extends OracleTriggerStep {
state: "notExecuted" | "rejected" | "committed" | "unknown";
verification: "applied" | "deleted" | "unverified" | "mismatch" | "unchanged" | "valid" | "invalid";
error?: string;
readbackError?: string;
receipt?: "accepted" | "unknown" | "rejected" | "notStarted";
snapshot?: OracleTriggerSnapshot;
}
export interface OracleTriggerExecutionResult {
steps: OracleTriggerStepResult[];
snapshot?: OracleTriggerSnapshot;
cancelled?: boolean;
refreshError?: string;
}
interface ConnectionIdentity {
revision: number;
fingerprint: string;
}
const planConnections = new WeakMap<OracleTriggerPlan, ConnectionIdentity>();
const snapshotConnections = new WeakMap<OracleTriggerSnapshot, ConnectionIdentity>();
function connectionIdentity(target: Pick<OracleTriggerTarget, "connectionId">): ConnectionIdentity {
const store = useConnectionStore();
const config = store.getConfig(target.connectionId);
if (!config || !store.connectedIds.has(target.connectionId)) throw new Error("Reconnect the trigger's connection before preparing a write");
return { revision: store.connectionStateRevision(target.connectionId), fingerprint: connectionConfigFingerprint(config) };
}
function assertConnection(target: Pick<OracleTriggerTarget, "connectionId">, expected: ConnectionIdentity): void {
const current = connectionIdentity(target);
if (current.revision !== expected.revision || current.fingerprint !== expected.fingerprint) throw new Error("The connection changed; reload the trigger and prepare a new preview");
}
function sourceIdentity(target: OracleTriggerTarget): SourceIdentitySnapshot {
return Object.freeze(captureSourceIdentity({ connectionId: target.connectionId, database: target.database, schema: target.owner, name: target.name, objectType: "TRIGGER" }));
}
function freezeSource(raw: ObjectSource, metadata: OracleTriggerMetadata): void {
if (metadata.parent) Object.freeze(metadata.parent);
if (metadata.definition) Object.freeze(metadata.definition);
metadata.errors?.forEach(Object.freeze);
if (metadata.errors) Object.freeze(metadata.errors);
Object.values(metadata.reads).forEach((read) => read && Object.freeze(read));
Object.freeze(metadata.reads);
Object.freeze(metadata);
if (raw.trigger) Object.freeze(raw.trigger);
Object.freeze(raw);
}
async function fetchSnapshot(target: Readonly<OracleTriggerTarget>, connection: ConnectionIdentity): Promise<OracleTriggerSnapshot> {
assertConnection(target, connection);
const identity = sourceIdentity(target);
const response = await api.getObjectSource(target.connectionId, target.database, target.owner, target.name, "TRIGGER", undefined, undefined, { identityMode: "exact", ...(target.catalog === undefined ? {} : { catalog: target.catalog }) });
assertConnection(target, connection);
return snapshotFromResponse(target, response, identity, connection);
}
function snapshotFromResponse(target: Readonly<OracleTriggerTarget>, response: ObjectSource, identity: Readonly<SourceIdentitySnapshot>, connection: ConnectionIdentity): OracleTriggerSnapshot {
// ObjectSource is the JSON transport DTO. Copy its optional values without
// structuredClone's inability to read a Vue proxy supplied by a consumer.
const raw: ObjectSource = JSON.parse(JSON.stringify(response));
const metadata = exactOracleTriggerMetadata(raw.trigger);
if (!metadata || raw.object_type !== "TRIGGER" || raw.name !== target.name || raw.schema !== target.owner || metadata.owner !== target.owner || metadata.name !== target.name) throw new Error("Exact trigger identity was not verified; reload or update the metadata provider");
const state = metadata.reads.identity?.state;
if (state !== "empty" && (state !== "available" || typeof metadata.objectId !== "string" || metadata.objectId.length === 0)) throw new Error("The trigger object identity is unavailable; keep the draft and reload");
freezeSource(raw, metadata);
const snapshot = Object.freeze({ target, raw, metadata, identity, exists: state !== "empty" });
snapshotConnections.set(snapshot, connection);
return snapshot;
}
/** Read-only viewing retains old/partial provider text without authorizing an exact write. */
export async function readOracleTriggerSource(target: OracleTriggerTarget): Promise<{ raw: Readonly<ObjectSource>; snapshot?: OracleTriggerSnapshot; identityError?: string }> {
if (!target.owner.length || !target.name.length || !target.executionSchema.length) throw new Error("Select the exact trigger owner/name and execution schema");
const fixed = Object.freeze({ ...target });
const connection = connectionIdentity(fixed);
const identity = sourceIdentity(fixed);
const raw = await api.getObjectSource(fixed.connectionId, fixed.database, fixed.owner, fixed.name, "TRIGGER", undefined, undefined, { identityMode: "exact", ...(fixed.catalog === undefined ? {} : { catalog: fixed.catalog }) });
assertConnection(fixed, connection);
try {
const snapshot = snapshotFromResponse(fixed, raw, identity, connection);
const renewed = Object.freeze({ ...snapshot, identity: Object.freeze(renewSourceIdentity(snapshot.identity)) });
snapshotConnections.set(renewed, connection);
return { raw: renewed.raw, snapshot: renewed };
} catch (error) {
return { raw, identityError: formatError(error) };
}
}
export async function readOracleTriggerSnapshot(target: OracleTriggerTarget): Promise<OracleTriggerSnapshot> {
const loaded = await readOracleTriggerSource(target);
if (!loaded.snapshot) throw new Error(loaded.identityError);
return loaded.snapshot;
}
export interface OracleTriggerPlanInput {
target: OracleTriggerTarget;
action: OracleTriggerAction;
source?: string;
/** The authoritative version loaded before the user's edits, not a fresh replacement for it. */
baseline?: OracleTriggerSnapshot;
selection?: OracleTriggerSqlBinding;
enabled?: boolean;
/** Optional identity already shown by the calling list/form, never inferred from a label. */
expectedObjectId?: string;
}
export async function prepareOracleTriggerPlan(input: OracleTriggerPlanInput): Promise<OracleTriggerPlan> {
const action = input.action;
const draft = input.source,
baseline = input.baseline,
requestedEnabled = input.enabled;
const selection = input.selection && { ...input.selection };
const expectedObjectId = input.expectedObjectId;
if (!["enable", "disable", "compile", "create", "replace", "delete"].includes(action)) throw new Error("Unsupported trigger action");
if (action === "replace") {
if (!baseline || !sameTarget(baseline.target, input.target)) throw new Error("Reload the complete trigger baseline before replacing it");
const loadedConnection = snapshotConnections.get(baseline);
if (!loadedConnection) throw new Error("Reload the authoritative trigger baseline before replacing it");
assertConnection(input.target, loadedConnection);
assertSourceIdentity(baseline.identity);
}
const connection = connectionIdentity(input.target);
const before = await readOracleTriggerSnapshot(input.target);
assertConnection(before.target, connection);
if (expectedObjectId !== undefined && before.metadata.objectId !== expectedObjectId) throw new Error("The displayed trigger was replaced; keep the draft and reread its identity");
if (action === "create" ? before.exists : !before.exists) throw new Error(action === "create" ? "A visible trigger already exists; reload it before preparing a replacement" : "No visible trigger matches this target; refresh before preparing the action");
if (baseline && action === "replace" && !sameSnapshot(baseline, before)) throw new Error("The trigger changed since the loaded baseline; keep the draft and reload");
const metadata = before.metadata;
const relation = metadata.scope === "TABLE" || metadata.scope === "VIEW";
assertActionReadability(before, action);
if (metadata.engine === "dm" && !/(?:^|\D)8\./.test(metadata.engineVersion ?? "")) throw new Error("The connected DM8 version could not be verified for this action");
const databaseType: OracleTriggerDatabaseType = metadata.engine === "dm" ? "dameng" : metadata.engine;
let expectedEnabled: boolean | undefined;
let expectedAfter: OracleTriggerPlan["expectedAfter"];
let parentBefore: readonly string[] | undefined;
let steps: OracleTriggerStep[];
if (action === "compile" && oracleCompileUnsupportedReason(databaseType, "TRIGGER", { triggerProfile: metadata })) throw new Error("Trigger compilation has not been verified for the connected engine/version");
if (action === "create" || action === "replace") {
if (typeof draft !== "string" || !draft.trim()) throw new Error("Enter one complete trigger definition");
if (action === "replace") {
const loaded = await inspectExactOracleTriggerSource(before.raw, metadata.owner, metadata.name);
if (!loaded.triggerSource.complete) throw new Error(loaded.triggerSource.error || "Reload the complete trigger baseline before replacing it");
if (metadata.reads.enabled?.state !== "available" || typeof before.raw.trigger?.enabled !== "boolean") throw new Error("Read the actual enabled state before replacing the trigger");
}
const fallback = selection ?? (action === "replace" ? oracleTriggerSourceBinding(metadata) : undefined);
const inspected = await api.prepareOracleTriggerSql({ databaseType, owner: metadata.owner, name: metadata.name, source: draft, purpose: "inspect", binding: selection });
const binding = candidateBinding(inspected, fallback);
if (!oracleTriggerDefinitionScopes(metadata).includes(binding.scope)) throw new Error("Full trigger creation/replacement is unavailable for this scope on the connected engine/version; OceanBase Oracle 4.2.5.7 supports TABLE/VIEW in this workflow");
if (metadata.engine === "dm" && action === "replace" && !matchesBinding(metadata, binding)) throw new Error("DM cannot replace this trigger with a different owning object or scope; keep the draft");
const proof = await verifyBinding(before.target, metadata.engine, binding);
const desiredEnabled = requestedEnabled ?? (action === "replace" ? before.raw.trigger!.enabled : (inspected.inlineEnabled ?? true));
if (typeof desiredEnabled !== "boolean") throw new Error("Read or select the trigger's enabled state before preparing the definition");
expectedEnabled = desiredEnabled;
const prepared = await api.prepareOracleTriggerSql({ databaseType, owner: metadata.owner, name: metadata.name, source: draft, purpose: action, binding, enabled: expectedEnabled });
if (typeof prepared.comparisonSource !== "string") throw new Error("Update the trigger SQL provider before preparing this write");
expectedAfter = Object.freeze({ binding: Object.freeze(binding), proof: Object.freeze(proof), definition: prepared.definition, comparisonSource: prepared.comparisonSource });
steps = [{ action, sql: prepared.definition }];
if (prepared.requiresStateRestore) {
const sql = buildTriggerToggleSql({ databaseType, schema: metadata.owner, triggerName: metadata.name, enabled: false, identityMode: "exact", scope: binding.scope });
if (!sql) throw new Error("Native disabled-state restoration is unavailable for this trigger scope");
steps.push({ action: "disable", sql });
}
} else if (action === "delete") {
const binding = oracleTriggerSourceBinding(metadata);
if (binding && relation) {
// The optional parent read is evidence for the result, not a new DROP privilege prerequisite.
try {
parentBefore = Object.freeze(await verifyBinding(before.target, metadata.engine, binding));
} catch {
/* report unverifiable parent on readback */
}
}
const sql = await api.buildDropObjectSql({ databaseType, objectType: "TRIGGER", schema: metadata.owner, name: metadata.name });
steps = [{ action, sql }];
} else {
expectedEnabled = action === "compile" ? undefined : action === "enable";
const sql =
action === "compile"
? buildOracleCompileSql(databaseType, metadata.owner, { name: metadata.name, type: "TRIGGER" }, { triggerProfile: metadata })
: buildTriggerToggleSql({ databaseType, schema: metadata.owner, triggerName: metadata.name, enabled: expectedEnabled!, identityMode: "exact", scope: metadata.scope });
if (!sql) throw new Error("This native trigger action is unavailable for the verified engine and scope");
steps = action !== "compile" && metadata.reads.enabled?.state === "available" && before.raw.trigger?.enabled === expectedEnabled ? [] : [{ action, sql }];
}
const plan: OracleTriggerPlan = Object.freeze({ target: before.target, action, before, expectedEnabled, expectedAfter, parentBefore, steps: Object.freeze(steps.map((step) => Object.freeze(step))) });
assertSourceIdentity(before.identity);
assertConnection(before.target, connection);
planConnections.set(plan, connection);
return plan;
}
export async function executeOracleTriggerPlan(
plan: OracleTriggerPlan,
options: { confirmed: boolean; confirmationScope?: string; isCurrent?: () => boolean; timeoutSecs?: number; refresh?: (target: Readonly<OracleTriggerTarget>, snapshot?: OracleTriggerSnapshot) => Promise<void> },
): Promise<OracleTriggerExecutionResult> {
return executePreparedTriggerPlan(plan, options, true);
}
async function executePreparedTriggerPlan(
plan: OracleTriggerPlan,
options: { confirmed: boolean; confirmationScope?: string; isCurrent?: () => boolean; timeoutSecs?: number; refresh?: (target: Readonly<OracleTriggerTarget>, snapshot?: OracleTriggerSnapshot) => Promise<void> },
guard: boolean,
): Promise<OracleTriggerExecutionResult> {
const cancelled = (): OracleTriggerExecutionResult => ({ steps: plan.steps.map((step) => ({ ...step, state: "notExecuted", verification: "unverified" })), cancelled: true });
if (!options.confirmed || options.isCurrent?.() === false) return cancelled();
const connection = planConnections.get(plan);
if (!connection) throw new Error("Prepare a new trigger preview before executing it");
assertSourceIdentity(plan.before.identity);
assertConnection(plan.target, connection);
const run = async (): Promise<OracleTriggerExecutionResult> => {
if (options.isCurrent?.() === false) return cancelled();
assertSourceIdentity(plan.before.identity);
assertConnection(plan.target, connection);
const frozen = freezeSourceIdentities([plan.before.identity]);
let dispatched = false;
try {
let latest = await fetchSnapshot(plan.target, connection);
if (!sameSnapshot(plan.before, latest)) throw new Error("The trigger changed after the preview; keep the draft and reload");
assertActionReadability(latest, plan.action);
if (plan.expectedAfter && !sameProof(plan.expectedAfter.proof, await verifyBinding(plan.target, latest.metadata.engine, plan.expectedAfter.binding))) throw new Error("The owning object or scope changed after the preview; keep the draft and reload");
if (options.isCurrent?.() === false) return cancelled();
const result: OracleTriggerExecutionResult = { steps: [], snapshot: latest };
for (const [index, step] of plan.steps.entries()) {
if (index && (result.steps[index - 1].state !== "committed" || result.steps[index - 1].verification === "invalid" || options.isCurrent?.() === false)) {
result.steps.push({ ...step, state: "notExecuted", verification: "unverified" });
continue;
}
try {
assertConnection(plan.target, connection);
} catch (error) {
if (!index) throw error;
result.steps.push({ ...step, state: "notExecuted", verification: "unverified", error: formatError(error) });
continue;
}
frozen.markDispatched();
dispatched = true;
let accepted = false;
let writeError: unknown;
try {
const timeoutSecs = options.timeoutSecs ?? queryTimeoutSecsForConnection(useConnectionStore().getConfig(plan.target.connectionId), useSettingsStore().editorSettings.globalQueryTimeoutSecs);
const receipt = await api.executeQuery(plan.target.connectionId, plan.target.database, step.sql, plan.target.executionSchema, undefined, { catalog: plan.target.catalog, timeoutSecs });
if (receipt.execution_error) throw new BackendErrorException(receipt.error || "Trigger statement failed");
accepted = true;
} catch (error) {
writeError = error;
}
// A failed/lost receipt does not establish rejection. Always read the
// fixed target; an attempted statement is never dispatched a second time.
let after: OracleTriggerSnapshot | undefined;
let readbackError: string | undefined;
let verification: OracleTriggerStepResult["verification"] = "unverified";
try {
after = await fetchSnapshot(plan.target, connection);
verification = await verifyStep(plan, step, latest, after, index);
} catch (error) {
readbackError = formatError(error);
}
const refusal = writeError === undefined ? "unknown" : knownReceiptFailure(writeError, latest.metadata.engine);
if (refusal !== "unknown" && after && sameSnapshot(latest, after)) verification = "unchanged";
const verified = verification === "applied" || verification === "deleted" || verification === "valid" || verification === "invalid";
const state: OracleTriggerStepResult["state"] = refusal === "notStarted" ? "notExecuted" : refusal === "rejected" ? "rejected" : accepted && verified ? "committed" : "unknown";
result.steps.push({ ...step, state, verification, snapshot: after, receipt: accepted ? "accepted" : refusal, ...(writeError === undefined ? {} : { error: formatError(writeError) }), ...(readbackError === undefined ? {} : { readbackError }) });
result.snapshot = after;
if (after) latest = after;
}
return result;
} finally {
if (dispatched) frozen.finish();
else frozen.cancel();
}
};
const guarded =
!guard || plan.steps.length === 0
? await run()
: await executeWithProductionSqlGuard<OracleTriggerExecutionResult>({
connection: useConnectionStore().getConfig(plan.target.connectionId),
database: plan.target.database,
sql: plan.steps.map((step) => step.sql).join("\n"),
scopeId: options.confirmationScope,
execute: run,
});
if (!guarded) return cancelled();
if (guarded.snapshot) {
const snapshot = guarded.snapshot;
try {
const renewed = Object.freeze({ ...snapshot, identity: Object.freeze(renewSourceIdentity(snapshot.identity)) });
snapshotConnections.set(renewed, connection);
guarded.snapshot = renewed;
for (const step of guarded.steps) if (step.snapshot === snapshot) step.snapshot = renewed;
} catch (error) {
guarded.refreshError = formatError(error);
}
}
if (guarded.steps.some((step) => step.receipt !== undefined)) {
try {
const parents = [plan.before.metadata.parent, guarded.snapshot?.metadata.parent].filter((parent): parent is NonNullable<OracleTriggerMetadata["parent"]> => !!parent);
const request = { connectionId: plan.target.connectionId, database: plan.target.database, catalog: plan.target.catalog, schema: plan.target.owner, tableName: plan.target.name, objectType: "TRIGGER" as const };
const invalidations: Promise<unknown>[] = [invalidateObjectDdl(request, { metadata: false, strict: true }), useConnectionStore().invalidateOracleTriggerLists(plan.target, parents)];
for (const parent of parents) {
for (const objectType of parent.objectType === "VIEW" ? (["VIEW", undefined] as const) : ([undefined] as const)) invalidations.push(invalidateObjectMetadataFacet({ ...request, schema: parent.owner, tableName: parent.name, objectType }, "triggers", { strict: true }));
}
const results = await Promise.allSettled(invalidations);
for (const result of results) if (result.status === "rejected") throw result.reason;
} catch (error) {
guarded.refreshError = [guarded.refreshError, formatError(error)].filter(Boolean).join("\n");
}
}
if (
["enable", "disable", "compile"].includes(plan.action) &&
!guarded.cancelled &&
guarded.snapshot?.exists &&
guarded.snapshot.metadata.objectId === plan.before.metadata.objectId &&
guarded.snapshot.raw.trigger &&
guarded.steps.every((step) => step.state === "committed" && ["applied", "valid", "invalid", "unchanged"].includes(step.verification))
) {
try {
assertConnection(plan.target, connection);
assertSourceIdentity(guarded.snapshot.identity);
useConnectionStore().syncOracleTriggerNodeState(plan.target, guarded.snapshot.raw.trigger);
} catch (error) {
guarded.refreshError = [guarded.refreshError, formatError(error)].filter(Boolean).join("\n");
}
}
if (!guarded.cancelled && options.refresh) {
try {
assertConnection(plan.target, connection);
await options.refresh(plan.target, guarded.snapshot);
} catch (error) {
guarded.refreshError = [guarded.refreshError, formatError(error)].filter(Boolean).join("\n");
}
}
return guarded;
}
export interface OracleTriggerStructureStepResult {
statementIndex: number;
sql: string;
state: OracleTriggerStepResult["state"];
elapsedMs?: number;
error?: string;
trigger?: OracleTriggerStepResult;
}
export function assertTriggerStructureSql(statements: readonly string[], operation: Readonly<OracleTriggerStructureOperation>, plan: OracleTriggerPlan): void {
if (plan.steps.length !== operation.statementCount || plan.steps.some((step, index) => step.sql !== statements[operation.statementIndex + index])) throw new Error("The actual trigger SQL differs from the confirmed table preview; regenerate it");
}
export interface OracleTriggerStructureExecutionResult {
steps: OracleTriggerStructureStepResult[];
triggerResults: { draftId: string; action: OracleTriggerAction; result: OracleTriggerExecutionResult }[];
cancelled?: boolean;
}
const attemptedStructurePlans = new WeakSet<OracleTriggerStructurePlan>();
/** The original allowed structure order, through the existing single-statement seam. */
export async function executeOracleTriggerStructurePlan(plan: OracleTriggerStructurePlan, options: { confirmed: boolean; confirmationScope?: string; isCurrent: () => boolean; timeoutSecs?: number; preflight?: () => Promise<void> }): Promise<OracleTriggerStructureExecutionResult> {
if (attemptedStructurePlans.has(plan)) throw new Error("This structure sequence was already attempted; reread and preview only the remaining changes");
return executeTriggerSequence(
{
target: plan.target,
connection: { revision: plan.revision, fingerprint: plan.configFingerprint },
engine: plan.target.databaseType === "dameng" ? "dm" : plan.target.databaseType,
statements: plan.statements,
groups: plan.groups.map((group) => ({
id: group.operation.draftId,
action: group.operation.action,
statementIndex: group.operation.statementIndex,
statementCount: group.operation.statementCount,
// CREATE TABLE has to precede the new parent's identity proof.
prepare: () => (group.plan ? Promise.resolve(group.plan) : prepareOracleTriggerPlan(group.afterTableCreate!)),
})),
markAttempted: () => attemptedStructurePlans.add(plan),
},
options,
);
}
export interface OracleTriggerDropBatchEntry {
id: string;
sql: string;
triggerPlan?: OracleTriggerPlan;
executionSchema?: string;
}
export interface OracleTriggerDropBatchPlan {
target: Readonly<Pick<OracleTriggerTarget, "connectionId" | "database" | "catalog" | "executionSchema">>;
entries: readonly Readonly<OracleTriggerDropBatchEntry>[];
engine: OracleTriggerMetadata["engine"];
}
const dropBatchConnections = new WeakMap<OracleTriggerDropBatchPlan, ConnectionIdentity>();
const attemptedDropBatches = new WeakSet<OracleTriggerDropBatchPlan>();
/** Bind generated non-trigger SQL and authoritative trigger plans before confirmation. */
export function prepareOracleTriggerDropBatchPlan(input: OracleTriggerDropBatchPlan): OracleTriggerDropBatchPlan {
const target = Object.freeze({ ...input.target });
const connection = connectionIdentity(target);
const ids = new Set<string>();
let triggerCount = 0;
const entries = input.entries.map((entry) => {
if (!entry.sql.trim() || ids.has(entry.id)) throw new Error("Regenerate the complete object deletion preview");
ids.add(entry.id);
if (entry.triggerPlan) {
const trigger = entry.triggerPlan;
const originalConnection = planConnections.get(trigger);
if (
!originalConnection ||
trigger.action !== "delete" ||
trigger.steps.length !== 1 ||
trigger.steps[0].sql !== entry.sql ||
trigger.before.metadata.engine !== input.engine ||
trigger.target.connectionId !== target.connectionId ||
trigger.target.database !== target.database ||
trigger.target.catalog !== target.catalog
)
throw new Error("The trigger deletion differs from the confirmed object selection");
assertConnection(target, originalConnection);
assertSourceIdentity(trigger.before.identity);
triggerCount++;
}
return Object.freeze({ ...entry });
});
if (!triggerCount) throw new Error("Use the existing object deletion path for a selection without exact triggers");
const plan = Object.freeze({ target, entries: Object.freeze(entries), engine: input.engine });
dropBatchConnections.set(plan, connection);
return plan;
}
export async function executeOracleTriggerDropBatchPlan(plan: OracleTriggerDropBatchPlan, options: { confirmed: boolean; confirmationScope?: string; isCurrent: () => boolean; timeoutSecs?: number; onProgress?: (completed: number) => void }): Promise<OracleTriggerStructureExecutionResult> {
const connection = dropBatchConnections.get(plan);
if (!connection || attemptedDropBatches.has(plan)) throw new Error("Reread the objects and preview only the remaining deletions");
return executeTriggerSequence(
{
target: plan.target,
connection,
engine: plan.engine,
statements: plan.entries.map((entry) => entry.sql),
statementSchemas: plan.entries.map((entry) => (Object.prototype.hasOwnProperty.call(entry, "executionSchema") ? entry.executionSchema : plan.target.executionSchema)),
groups: plan.entries.flatMap((entry, statementIndex) => (entry.triggerPlan ? [{ id: entry.id, action: "delete" as const, statementIndex, statementCount: 1, prepare: () => Promise.resolve(entry.triggerPlan!) }] : [])),
markAttempted: () => attemptedDropBatches.add(plan),
},
options,
);
}
/** Shared serial seam: one production/readonly confirmation, stop on unknown. */
async function executeTriggerSequence(
sequence: {
target: Pick<OracleTriggerTarget, "connectionId" | "database" | "catalog" | "executionSchema">;
connection: ConnectionIdentity;
engine: OracleTriggerMetadata["engine"];
statements: readonly string[];
statementSchemas?: readonly (string | undefined)[];
groups: { id: string; action: OracleTriggerAction; statementIndex: number; statementCount: number; prepare: () => Promise<OracleTriggerPlan> }[];
markAttempted: () => unknown;
},
options: { confirmed: boolean; confirmationScope?: string; isCurrent: () => boolean; timeoutSecs?: number; preflight?: () => Promise<void>; onProgress?: (completed: number) => void },
): Promise<OracleTriggerStructureExecutionResult> {
const result: OracleTriggerStructureExecutionResult = { steps: sequence.statements.map((sql, statementIndex) => ({ statementIndex, sql, state: "notExecuted" })), triggerResults: [] };
if (!options.confirmed || !options.isCurrent()) return { ...result, cancelled: true };
const fixed = sequence.target;
const run = async () => {
if (!options.isCurrent()) return { ...result, cancelled: true };
try {
await options.preflight?.();
} catch (error) {
if (result.steps[0]) result.steps[0].error = formatError(error);
return result;
}
for (let index = 0; index < sequence.statements.length;) {
if (!options.isCurrent()) break;
const row = result.steps[index];
try {
assertConnection(fixed, sequence.connection);
const group = sequence.groups.find((item) => item.statementIndex === index);
if (group) {
const triggerPlan = await group.prepare();
if (triggerPlan.steps.length !== group.statementCount || triggerPlan.steps.some((step, offset) => step.sql !== sequence.statements[index + offset])) throw new Error("The trigger SQL differs from the confirmed preview; regenerate it");
sequence.markAttempted();
const outcome = await executePreparedTriggerPlan(triggerPlan, { confirmed: true, isCurrent: options.isCurrent, timeoutSecs: options.timeoutSecs }, false);
result.triggerResults.push({ draftId: group.id, action: group.action, result: outcome });
outcome.steps.forEach((step, offset) => Object.assign(result.steps[index + offset], { state: step.state, error: step.error || step.readbackError, trigger: step }));
options.onProgress?.(index + outcome.steps.filter((step) => step.state !== "notExecuted").length);
if (outcome.cancelled || outcome.steps.some((step) => step.state !== "committed" || step.verification === "invalid")) break;
index += group.statementCount;
} else {
sequence.markAttempted();
const startedAt = Date.now();
let dispatched = false;
try {
dispatched = true;
const receipt = await api.executeQuery(fixed.connectionId, fixed.database, row.sql, sequence.statementSchemas ? sequence.statementSchemas[index] : fixed.executionSchema, undefined, { catalog: fixed.catalog, timeoutSecs: options.timeoutSecs });
if (receipt.execution_error) throw new BackendErrorException(receipt.error || "Structure statement failed");
row.state = "committed";
} catch (error) {
const refusal = knownReceiptFailure(error, sequence.engine);
row.state = !dispatched || refusal === "notStarted" ? "notExecuted" : refusal === "rejected" ? "rejected" : "unknown";
row.error = formatError(error);
break;
} finally {
row.elapsedMs = Date.now() - startedAt;
}
index++;
options.onProgress?.(index);
}
} catch (error) {
row.error = formatError(error);
break;
}
}
return result;
};
return (await executeWithProductionSqlGuard({ connection: useConnectionStore().getConfig(fixed.connectionId), database: fixed.database, sql: sequence.statements.join("\n\n"), scopeId: options.confirmationScope, execute: run })) ?? { ...result, cancelled: true };
}
function samePhysicalTrigger(before: OracleTriggerSnapshot, after: OracleTriggerSnapshot): boolean {
const a = before.metadata,
b = after.metadata;
return (
before.exists &&
after.exists &&
a.objectId === b.objectId &&
a.engine === b.engine &&
a.engineVersion === b.engineVersion &&
a.scope === b.scope &&
(a.scopeOwner ?? null) === (b.scopeOwner ?? null) &&
(a.parent?.owner ?? null) === (b.parent?.owner ?? null) &&
(a.parent?.name ?? null) === (b.parent?.name ?? null) &&
(a.parent?.objectType ?? null) === (b.parent?.objectType ?? null) &&
(a.parent?.objectId ?? null) === (b.parent?.objectId ?? null)
);
}
function sameSnapshot(before: OracleTriggerSnapshot, after: OracleTriggerSnapshot): boolean {
return (
(before.exists ? samePhysicalTrigger(before, after) : !after.exists && before.metadata.engine === after.metadata.engine && before.metadata.engineVersion === after.metadata.engineVersion) &&
(before.metadata.lastDdlTime ?? null) === (after.metadata.lastDdlTime ?? null) &&
(before.raw.trigger?.enabled ?? null) === (after.raw.trigger?.enabled ?? null) &&
(before.raw.trigger?.valid ?? null) === (after.raw.trigger?.valid ?? null) &&
before.raw.source === after.raw.source
);
}
function sameTarget(a: OracleTriggerTarget, b: OracleTriggerTarget): boolean {
return a.connectionId === b.connectionId && a.database === b.database && a.catalog === b.catalog && a.owner === b.owner && a.name === b.name;
}
function assertActionReadability(snapshot: OracleTriggerSnapshot, action: OracleTriggerAction): void {
const metadata = snapshot.metadata;
const relation = metadata.scope === "TABLE" || metadata.scope === "VIEW";
if ((action === "enable" || action === "disable") && (metadata.reads.scope?.state !== "available" || (relation && (metadata.reads.parent?.state !== "available" || !metadata.parent || metadata.parent.objectType !== metadata.scope))))
throw new Error("Verify the trigger scope and owning object before preparing this action");
if (action === "replace" && (!metadata.definition?.complete || metadata.reads.definition?.state !== "available" || metadata.reads.enabled?.state !== "available" || typeof snapshot.raw.trigger?.enabled !== "boolean"))
throw new Error("The complete trigger definition or enabled state is unavailable; keep the draft and reload");
}
function candidateBinding(prepared: PreparedOracleTriggerSql, selection?: OracleTriggerSqlBinding): OracleTriggerSqlBinding {
const header = prepared.header;
if (header.scope === "RELATION") {
if (selection && (selection.scope === "TABLE" || selection.scope === "VIEW") && selection.name === header.name && (header.owner === undefined || header.owner === null || header.owner === selection.owner)) return { ...selection, pluggable: false };
if (header.owner && header.name) return { scope: header.viewOnly ? "VIEW" : "TABLE", owner: header.owner, name: header.name, pluggable: false };
} else if (header.scope === "SCHEMA") {
const owner = header.owner ?? (selection?.scope === "SCHEMA" ? selection.owner : undefined);
if (owner) return { scope: "SCHEMA", owner, pluggable: false };
} else if (header.scope === "DATABASE" || header.scope === "TIMER") return { scope: header.scope, pluggable: header.pluggable };
throw new Error("Select or explicitly qualify the candidate's actual owning object/scope before preparing a write");
}
function matchesBinding(metadata: Readonly<OracleTriggerMetadata>, binding: Readonly<OracleTriggerSqlBinding>): boolean {
if (metadata.scope !== binding.scope) return false;
if (binding.scope === "TABLE" || binding.scope === "VIEW") return metadata.parent?.owner === binding.owner && metadata.parent?.name === binding.name && metadata.parent?.objectType === binding.scope;
if (binding.scope === "SCHEMA") return metadata.scopeOwner === binding.owner;
return true;
}
function sqlString(value: string): string {
return `'${value.replaceAll("'", "''")}'`;
}
async function metadataQuery(target: Readonly<OracleTriggerTarget>, sql: string): Promise<QueryResult> {
const result = await api.executeQuery(target.connectionId, target.database, sql, target.executionSchema, undefined, { catalog: target.catalog, maxRows: 2 });
if (result.execution_error) throw new BackendErrorException(result.error || "Trigger metadata query failed");
if (result.truncated || result.has_more || result.rows.length > 1 || result.large_value_cells?.length) throw new Error("Trigger metadata is incomplete or ambiguous; keep the draft and reload");
return result;
}
/** Only action-relevant scope queries run: TABLE/VIEW never require a database-wide privilege. */
async function verifyBinding(target: Readonly<OracleTriggerTarget>, engine: OracleTriggerMetadata["engine"], binding: Readonly<OracleTriggerSqlBinding>): Promise<string[]> {
let sql: string;
let expected: (string | undefined)[];
if (binding.scope === "TABLE" || binding.scope === "VIEW") {
if (!binding.owner || !binding.name) throw new Error("Select the exact owning object");
sql = `SELECT OWNER, OBJECT_NAME, OBJECT_TYPE, TO_CHAR(OBJECT_ID) AS OBJECT_ID FROM ALL_OBJECTS WHERE OWNER = ${sqlString(binding.owner)} AND OBJECT_NAME = ${sqlString(binding.name)} AND OBJECT_TYPE = ${sqlString(binding.scope)}`;
expected = [binding.owner, binding.name, binding.scope];
} else if (binding.scope === "SCHEMA") {
if (!binding.owner) throw new Error("Select the actual scope owner, not the trigger owner or execution schema");
sql = engine === "dm" ? `SELECT NAME, TO_CHAR(ID) AS SCHEMA_ID FROM SYS.SYSOBJECTS WHERE TYPE$ = 'SCH' AND NAME = ${sqlString(binding.owner)}` : `SELECT USERNAME, TO_CHAR(USER_ID) AS SCHEMA_ID FROM ALL_USERS WHERE USERNAME = ${sqlString(binding.owner)}`;
expected = [binding.owner];
} else {
sql = engine === "dm" ? "SELECT NAME, TO_CHAR(CREATE_TIME, 'YYYY-MM-DD HH24:MI:SS') AS CREATED FROM V$DATABASE" : "SELECT SYS_CONTEXT('USERENV','DB_UNIQUE_NAME') AS DATABASE_NAME, SYS_CONTEXT('USERENV','CON_ID') AS CONTAINER_ID, SYS_CONTEXT('USERENV','CON_NAME') AS CONTAINER_NAME FROM DUAL";
expected = [];
}
const result = await metadataQuery(target, sql);
const row = result.rows[0];
if (!row || row.some((value) => typeof value !== "string" || !value.length) || expected.some((value, index) => row[index] !== value) || row.length !== (binding.scope === "TABLE" || binding.scope === "VIEW" ? 4 : binding.scope === "SCHEMA" || engine === "dm" ? 2 : 3))
throw new Error("The actual owning object or scope could not be verified");
if (binding.pluggable && (engine !== "oracle" || row[1] === "0" || row[1] === "1")) throw new Error("The current pluggable database context could not be verified");
return row as string[];
}
function sameProof(a: readonly string[], b: readonly string[]): boolean {
return a.length === b.length && a.every((value, index) => value === b[index]);
}
async function verifyStep(plan: OracleTriggerPlan, step: Readonly<OracleTriggerStep>, before: OracleTriggerSnapshot, after: OracleTriggerSnapshot, index: number): Promise<OracleTriggerStepResult["verification"]> {
if (step.action === "delete") {
if (after.exists) return "mismatch";
await verifyDeleted(plan.target, after.metadata.engine);
if (before.metadata.scope === "TABLE" || before.metadata.scope === "VIEW") {
const binding = oracleTriggerSourceBinding(before.metadata);
if (!binding) throw new Error("The owning object could not be verified after deletion");
const proof = await verifyBinding(plan.target, before.metadata.engine, binding);
if (plan.parentBefore && !sameProof(plan.parentBefore, proof)) return "mismatch";
}
return "deleted";
}
if (!after.exists || after.metadata.engine !== before.metadata.engine || after.metadata.engineVersion !== before.metadata.engineVersion) return "unverified";
if (step.action !== "create" && before.metadata.objectId !== after.metadata.objectId) return "mismatch";
if (step.action === "create" || step.action === "replace") {
const expected = plan.expectedAfter!;
if (!matchesBinding(after.metadata, expected.binding) || !sameProof(expected.proof, await verifyBinding(plan.target, after.metadata.engine, expected.binding))) return "mismatch";
const inspected = await inspectExactOracleTriggerSource(after.raw, plan.target.owner, plan.target.name);
if (!inspected.triggerSource.complete) return "unverified";
const databaseType = after.metadata.engine === "dm" ? "dameng" : after.metadata.engine;
const prepared = await api.prepareOracleTriggerSql({ databaseType, owner: plan.target.owner, name: plan.target.name, source: inspected.editableSource, purpose: "replace", binding: expected.binding, enabled: plan.expectedEnabled });
if (typeof prepared.comparisonSource !== "string") return "unverified";
if (prepared.comparisonSource !== expected.comparisonSource) return "mismatch";
const restorePending = plan.steps.slice(index + 1).some((next) => next.action === "disable");
if (after.metadata.reads.enabled?.state !== "available" || typeof after.raw.trigger?.enabled !== "boolean") return "unverified";
if (!restorePending && after.raw.trigger.enabled !== plan.expectedEnabled) return "mismatch";
return after.metadata.reads.validity?.state === "available" && after.raw.trigger?.valid === false ? "invalid" : "applied";
}
if (!samePhysicalTrigger(before, after)) return "mismatch";
const preserved = await preservedTriggerSource(before, after);
if (preserved !== true) return preserved === false ? "mismatch" : "unverified";
if (step.action === "compile") return after.metadata.reads.validity?.state !== "available" || typeof after.raw.trigger?.valid !== "boolean" ? "unverified" : after.raw.trigger.valid ? "valid" : "invalid";
return after.metadata.reads.enabled?.state !== "available" || typeof after.raw.trigger?.enabled !== "boolean" ? "unverified" : after.raw.trigger.enabled === (step.action === "enable") ? "applied" : "mismatch";
}
async function preservedTriggerSource(before: OracleTriggerSnapshot, after: OracleTriggerSnapshot): Promise<boolean | undefined> {
if (!before.metadata.definition?.complete || before.metadata.reads.definition?.state !== "available") return true; // Native actions do not require a replaceable body.
const previous = await inspectExactOracleTriggerSource(before.raw, before.target.owner, before.target.name);
const current = await inspectExactOracleTriggerSource(after.raw, after.target.owner, after.target.name);
if (!previous.triggerSource.complete || !current.triggerSource.complete || !previous.triggerSource.prepared || !current.triggerSource.prepared) return;
const binding = candidateBinding(previous.triggerSource.prepared, oracleTriggerSourceBinding(before.metadata));
const databaseType = before.metadata.engine === "dm" ? "dameng" : before.metadata.engine;
// Only the already-validated CREATE/owner/state export wrapper is controlled.
// The actual header clauses, comments, body and literal whitespace stay in
// the whole definition comparison; no token fingerprint or newline folding.
const normalized = await Promise.all([previous.editableSource, current.editableSource].map((source) => api.prepareOracleTriggerSql({ databaseType, owner: before.target.owner, name: before.target.name, source, purpose: "replace", binding, enabled: false })));
if (normalized.some((definition) => typeof definition.comparisonSource !== "string")) return;
return normalized[0].comparisonSource === normalized[1].comparisonSource;
}
async function verifyDeleted(target: Readonly<OracleTriggerTarget>, engine: OracleTriggerMetadata["engine"]): Promise<void> {
if (engine !== "dm") {
const own = await metadataQuery(target, "SELECT USER AS SESSION_USER FROM DUAL");
if (own.rows[0]?.[0] === target.owner) return; // Successful exact empty read covers this user's own objects.
}
// Cross-owner ALL_* visibility can disappear after permission changes. Only
// a readable global catalog can prove absence, never the connection username.
const sql = `SELECT OWNER, OBJECT_NAME FROM DBA_OBJECTS WHERE OWNER = ${sqlString(target.owner)} AND OBJECT_NAME = ${sqlString(target.name)} AND OBJECT_TYPE = 'TRIGGER'`;
if ((await metadataQuery(target, sql)).rows.length) throw new Error("The trigger still exists in the global dictionary");
}
export async function verifyOracleTriggerDeletion(target: OracleTriggerTarget, plan?: OracleTriggerPlan): Promise<void> {
const connection = plan && planConnections.get(plan);
if (plan) {
if (!connection || plan.action !== "delete" || !sameTarget(target, plan.target)) throw new Error("Reload the original trigger deletion target");
assertConnection(target, connection);
}
const current = await readOracleTriggerSnapshot(target);
if (current.exists) throw new Error("The trigger still exists; retain its delete draft");
if (plan) {
if ((await verifyStep(plan, plan.steps[0], plan.before, current, 0)) !== "deleted") throw new Error("The owning object changed; retain the deletion result and refresh its identity");
assertConnection(target, connection!);
} else await verifyDeleted(current.target, current.metadata.engine);
}
function knownReceiptFailure(error: unknown, engine: OracleTriggerMetadata["engine"]): "notStarted" | "rejected" | "unknown" {
const normalized = normalizeBackendError(error);
if (normalized?.operationOutcome === "not_started") return "notStarted";
const diagnostics = normalized?.diagnostics;
if (normalized?.origin?.subsystem !== "database" || diagnostics?.category !== "sql" || diagnostics.stage !== "execute") return "unknown";
// A permission code in a transport/fetch error or in the submitted source is
// not a native SQL rejection. Inspect only the structured native SQL origin.
const vendor = typeof diagnostics.vendorCode === "number" ? Math.abs(diagnostics.vendorCode) : undefined;
const oraclePermission = engine !== "dm" && (vendor === 1031 || (vendor === undefined && /^\s*ORA-01031\b/.test(normalized.detail ?? "")));
return oraclePermission || (diagnostics.sqlState === "42501" && vendor !== 24344) ? "rejected" : "unknown";
}