Cb 1084 transactions

server/bundles/io.cloudbeaver.server/schema/service.sql.graphqls

@@ -44,6 +44,7 @@ type SQLContextInfo {
     id: ID!
     projectId: ID!
     connectionId: ID!
+    autoCommit: Boolean
     defaultCatalog: String
     defaultSchema: String
 
@@ -401,4 +402,26 @@ extend type Mutation {
 
     asyncSqlRowDataCountResult(taskId: ID!): Int!
 
+    @since(version: "24.0.1")
+    asyncSqlSetAutoCommit(
+        projectId: ID,
+        connectionId: ID!,
+        contextId: ID!,
+        autoCommit: Boolean!
+    ): AsyncTaskInfo!
+
+    @since(version: "24.0.1")
+    asyncSqlCommitTransaction(
+        projectId: ID,
+        connectionId: ID!,
+        contextId: ID!
+    ): AsyncTaskInfo!
+
+    @since(version: "24.0.1")
+    asyncSqlRollbackTransaction(
+        projectId: ID,
+        connectionId: ID!,
+        contextId: ID!
+    ): AsyncTaskInfo!
+
 }

server/bundles/io.cloudbeaver.server/src/io/cloudbeaver/service/sql/DBWServiceSQL.java

@@ -172,4 +172,22 @@
     @Nullable
     @WebAction
     Long getRowDataCountResult(@NotNull WebSession webSession, @NotNull String taskId) throws DBWebException;
+
+    @WebAction
+    WebAsyncTaskInfo asyncSqlSetAutoCommit(
+        @NotNull WebSession webSession,
+        @NotNull WebSQLContextInfo contextInfo,
+        boolean autoCommit
+    ) throws DBWebException;
+
+    @WebAction
+    WebAsyncTaskInfo asyncSqlRollbackTransaction(
+        @NotNull WebSession webSession,
+        @NotNull WebSQLContextInfo contextInfo
+    ) throws DBWebException;
+
+    @WebAction
+    WebAsyncTaskInfo asyncSqlCommitTransaction(
+        @NotNull WebSession webSession,
+        @NotNull WebSQLContextInfo sqlContext);
 }

server/bundles/io.cloudbeaver.server/src/io/cloudbeaver/service/sql/WebSQLContextInfo.java

@@ -19,20 +19,27 @@
 import io.cloudbeaver.DBWebException;
 import io.cloudbeaver.WebAction;
 import io.cloudbeaver.WebProjectImpl;
+import io.cloudbeaver.model.WebAsyncTaskInfo;
+import io.cloudbeaver.model.session.WebAsyncTaskProcessor;
 import io.cloudbeaver.model.session.WebSession;
 import io.cloudbeaver.model.session.WebSessionProvider;
 import org.jkiss.code.NotNull;
 import org.jkiss.dbeaver.DBException;
 import org.jkiss.dbeaver.Log;
+import org.jkiss.dbeaver.model.DBUtils;
 import org.jkiss.dbeaver.model.data.DBDAttributeBinding;
-import org.jkiss.dbeaver.model.exec.DBCException;
-import org.jkiss.dbeaver.model.exec.DBCExecutionContextDefaults;
-import org.jkiss.dbeaver.model.exec.DBExecUtils;
+import org.jkiss.dbeaver.model.exec.*;
+import org.jkiss.dbeaver.model.meta.Property;
+import org.jkiss.dbeaver.model.qm.QMTransactionState;
+import org.jkiss.dbeaver.model.qm.QMUtils;
+import org.jkiss.dbeaver.model.runtime.DBRProgressMonitor;
 import org.jkiss.dbeaver.model.struct.DBSDataContainer;
 import org.jkiss.dbeaver.model.struct.rdb.DBSCatalog;
 import org.jkiss.dbeaver.model.struct.rdb.DBSSchema;
+import org.jkiss.dbeaver.utils.RuntimeUtils;
 import org.jkiss.utils.CommonUtils;
 
+import java.lang.reflect.InvocationTargetException;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -170,4 +177,103 @@
     public WebSession getWebSession() {
         return processor.getWebSession();
     }
+
+
+    ///////////////////////////////////////////////////////
+    // Transactions
+
+    public WebAsyncTaskInfo setAutoCommit(boolean autoCommit) {
+        DBCExecutionContext context = processor.getExecutionContext();
+        DBCTransactionManager txnManager = DBUtils.getTransactionManager(context);
+        WebAsyncTaskProcessor<Boolean> runnable = new WebAsyncTaskProcessor<>() {
+            @Override
+            public void run(DBRProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
+                if (txnManager != null) {
+                    monitor.beginTask("Change connection auto-commit to " + autoCommit, 1);
+                    try {
+                        monitor.subTask("Change context '" + context.getContextName() + "' auto-commit state");
+                        txnManager.setAutoCommit(monitor, autoCommit);
+                        result = true;
+                    } catch (DBException e) {
+                        throw new InvocationTargetException(e);
+                    } finally {
+                        monitor.done();
+                    }
+                }
+
+            }
+        };
+        return getWebSession().createAndRunAsyncTask("Set auto-commit", runnable);
+
+    }
+
+    public WebAsyncTaskInfo commitTransaction() {
+        DBCExecutionContext context = processor.getExecutionContext();
+        DBCTransactionManager txnManager = DBUtils.getTransactionManager(context);
+        WebAsyncTaskProcessor<String> runnable = new WebAsyncTaskProcessor<>() {
+            @Override
+            public void run(DBRProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
+                if (txnManager != null) {
+                    QMTransactionState txnInfo = QMUtils.getTransactionState(context);
+                    try (DBCSession session = context.openSession(monitor, DBCExecutionPurpose.UTIL, "Commit transaction")) {
+                        txnManager.commit(session);
+                    } catch (DBCException e) {
+                        throw new InvocationTargetException(e);
+                    }
+                    result = """
+                    Transaction has been committed
+                    Query count: %s
+                    Duration: %s
+                    """.formatted(
+                        txnInfo.getUpdateCount(),
+                        RuntimeUtils.formatExecutionTime(System.currentTimeMillis() - txnInfo.getTransactionStartTime())
+                    );
+                }
+            }
+        };
+        return getWebSession().createAndRunAsyncTask("Commit transaction", runnable);
+    }
+
+
+    public WebAsyncTaskInfo rollbackTransaction() {
+        DBCExecutionContext context = processor.getExecutionContext();
+        DBCTransactionManager txnManager = DBUtils.getTransactionManager(context);
+        WebAsyncTaskProcessor<String> runnable = new WebAsyncTaskProcessor<>() {
+            @Override
+            public void run(DBRProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
+                if (txnManager != null) {
+                    QMTransactionState txnInfo = QMUtils.getTransactionState(context);
+                    try (DBCSession session = context.openSession(monitor, DBCExecutionPurpose.UTIL, "Rollback transaction")) {
+                        txnManager.rollback(session, null);
+                    } catch (DBCException e) {
+                        throw new InvocationTargetException(e);
+                    }
+                    result = """
+                    Transaction has been rolled back
+                    Query count: %s
+                    Duration: %s
+                    """.formatted(
+                        txnInfo.getUpdateCount(),
+                        RuntimeUtils.formatExecutionTime(System.currentTimeMillis() - txnInfo.getTransactionStartTime())
+                    );
+                }
+            }
+        };
+
+        return getWebSession().createAndRunAsyncTask("Rollback transaction", runnable);
+    }
+
+    @Property
+    public Boolean isAutoCommit() throws DBWebException {
+        DBCExecutionContext context = processor.getExecutionContext();
+        DBCTransactionManager txnManager = DBUtils.getTransactionManager(context);
+        if (txnManager == null) {
+            return null;
+        }
+        try {
+            return txnManager.isAutoCommit();
+        } catch (DBException e) {
+            throw new DBWebException("Error getting auto-commit parameter from context", e);
+        }
+    }
 }

server/bundles/io.cloudbeaver.server/src/io/cloudbeaver/service/sql/WebSQLProcessor.java

@@ -358,9 +358,15 @@ public WebSQLExecuteInfo updateResultsDataBatch(
             try (DBCSession session = executionContext.openSession(monitor, DBCExecutionPurpose.USER, "Update data in container")) {
                 DBCTransactionManager txnManager = DBUtils.getTransactionManager(executionContext);
                 boolean revertToAutoCommit = false;
-                if (txnManager != null && txnManager.isSupportsTransactions() && txnManager.isAutoCommit()) {
-                    txnManager.setAutoCommit(monitor, false);
-                    revertToAutoCommit = true;
+                boolean isAutoCommitEnabled = true;
+                DBCSavepoint savepoint = null;
+                if (txnManager != null) {
+                    isAutoCommitEnabled = txnManager.isAutoCommit();
+                    if (txnManager.isSupportsTransactions() && isAutoCommitEnabled) {
+                        txnManager.setAutoCommit(monitor, false);
+                        savepoint = txnManager.setSavepoint(monitor, null);
+                        revertToAutoCommit = true;
+                    }
                 }
                 try {
                     Map<String, Object> options = Collections.emptyMap();
@@ -375,17 +381,27 @@ public WebSQLExecuteInfo updateResultsDataBatch(
                         newResultSetRows.add(new WebSQLQueryResultSetRow(rowValues, null));
                     }
 
-                    if (txnManager != null && txnManager.isSupportsTransactions()) {
+                    if (txnManager != null && txnManager.isSupportsTransactions() && isAutoCommitEnabled) {
                         txnManager.commit(session);
                     }
                 } catch (Exception e) {
                     if (txnManager != null && txnManager.isSupportsTransactions()) {
-                        txnManager.rollback(session, null);
+                        txnManager.rollback(session, savepoint);
                     }
                     throw new DBCException("Error persisting data changes", e);
                 } finally {
-                    if (revertToAutoCommit) {
-                        txnManager.setAutoCommit(monitor, true);
+                    if (txnManager != null) {
+                        if (revertToAutoCommit) {
+                            txnManager.setAutoCommit(monitor, true);
+                        }
+                        try {
+                            if (savepoint != null) {
+                                txnManager.releaseSavepoint(monitor, savepoint);
+                            }
+                        } catch (Throwable e) {
+                            // Maybe savepoints not supported
+                            log.debug("Can't release savepoint", e);
+                        }
                     }
                 }
             }

server/bundles/io.cloudbeaver.server/src/io/cloudbeaver/service/sql/WebServiceBindingSQL.java

@@ -207,8 +207,23 @@ public void bindWiring(DBWBindingContext model) throws DBWebException {
                 getService(env).getRowDataCountResult(
                     getWebSession(env),
                     env.getArgument("taskId")
-            )
-        );
+            ))
+            .dataFetcher("asyncSqlSetAutoCommit", env ->
+                getService(env).asyncSqlSetAutoCommit(
+                    getWebSession(env),
+                    getSQLContext(env),
+                    env.getArgument("autoCommit")
+            ))
+            .dataFetcher("asyncSqlCommitTransaction", env ->
+                getService(env).asyncSqlCommitTransaction(
+                    getWebSession(env),
+                    getSQLContext(env)
+                ))
+            .dataFetcher("asyncSqlRollbackTransaction", env ->
+                getService(env).asyncSqlRollbackTransaction(
+                    getWebSession(env),
+                    getSQLContext(env)
+                ));
     }
 
     @NotNull

server/bundles/io.cloudbeaver.server/src/io/cloudbeaver/service/sql/impl/WebServiceSQL.java

@@ -48,7 +48,6 @@
 import org.jkiss.dbeaver.model.sql.registry.SQLGeneratorConfigurationRegistry;
 import org.jkiss.dbeaver.model.sql.registry.SQLGeneratorDescriptor;
 import org.jkiss.dbeaver.model.struct.DBSDataContainer;
-import org.jkiss.dbeaver.model.struct.DBSEntity;
 import org.jkiss.dbeaver.model.struct.DBSObject;
 import org.jkiss.dbeaver.model.struct.DBSWrapper;
 import org.jkiss.dbeaver.utils.RuntimeUtils;
@@ -579,4 +578,19 @@
         return null;
     }
 
+    @Override
+    public WebAsyncTaskInfo asyncSqlSetAutoCommit(@NotNull WebSession webSession, @NotNull WebSQLContextInfo contextInfo, boolean autoCommit) throws DBWebException {
+        return contextInfo.setAutoCommit(autoCommit);
+    }
+
+    @Override
+    public WebAsyncTaskInfo asyncSqlRollbackTransaction(@NotNull WebSession webSession, @NotNull WebSQLContextInfo contextInfo) throws DBWebException {
+        return contextInfo.rollbackTransaction();
+    }
+
+    @Override
+    public WebAsyncTaskInfo asyncSqlCommitTransaction(@NotNull WebSession webSession, @NotNull WebSQLContextInfo contextInfo) {
+        return contextInfo.commitTransaction();
+    }
+
 }

webapp/packages/core-connections/src/ConnectionExecutionContext/ConnectionExecutionContextResource.ts

@@ -134,6 +134,13 @@ export class ConnectionExecutionContextResource extends CachedMapResource<string
     });
   }
 
+  async refreshConnectionContexts(connection: IConnectionInfoParams) {
+    const contexts = this.values.filter(context => context.connectionId === connection.connectionId && context.projectId === connection.projectId);
+    const key = resourceKeyList(contexts.map(context => context.id));
+
+    await this.refresh(key);
+  }
+
   protected async loader(originalKey: ResourceKey<string>): Promise<Map<string, IConnectionExecutionContextInfo>> {
     const contextsList: IConnectionExecutionContextInfo[] = [];
     let projectId: string | undefined;

webapp/packages/core-connections/src/extensions/IExecutionContextProvider.ts

@@ -0,0 +1,22 @@
+/*
+ * CloudBeaver - Cloud Database Manager
+ * Copyright (C) 2020-2024 DBeaver Corp and others
+ *
+ * Licensed under the Apache License, Version 2.0.
+ * you may not use this file except in compliance with the License.
+ */
+import { createExtension, IExtension, isExtension } from '@cloudbeaver/core-extensions';
+
+import type { IConnectionExecutionContextInfo } from '../ConnectionExecutionContext/ConnectionExecutionContextResource';
+
+const EXECUTION_CONTEXT_PROVIDER_SYMBOL = Symbol('@extension/ExecutionContextProvider');
+
+export type IExecutionContextProvider<T = never> = (context: T) => IConnectionExecutionContextInfo | undefined;
+
+export function executionContextProvider<T>(provider: IExecutionContextProvider<T>) {
+  return createExtension<T>(provider, EXECUTION_CONTEXT_PROVIDER_SYMBOL);
+}
+
+export function isExecutionContextProvider<T>(obj: IExtension<T>): obj is IExecutionContextProvider<T> & IExtension<T> {
+  return isExtension(obj, EXECUTION_CONTEXT_PROVIDER_SYMBOL);
+}

webapp/packages/core-connections/src/index.ts

@@ -9,6 +9,7 @@ export * from './extensions/IObjectCatalogProvider';
 export * from './extensions/IObjectCatalogSetter';
 export * from './extensions/IObjectSchemaProvider';
 export * from './extensions/IObjectSchemaSetter';
+export * from './extensions/IExecutionContextProvider';
 export * from './NavTree/ConnectionNavNodeService';
 export * from './NavTree/NavNodeExtensionsService';
 export * from './NavTree/getConnectionFolderIdFromNodeId';

webapp/packages/core-sdk/src/queries/fragments/ExecutionContextInfo.gql

@@ -1,7 +1,8 @@
 fragment ExecutionContextInfo on SQLContextInfo {
-    id
-    projectId
-    connectionId
-    defaultCatalog
-    defaultSchema
-}
+  id
+  projectId
+  connectionId
+  autoCommit
+  defaultCatalog
+  defaultSchema
+}

webapp/packages/core-sdk/src/queries/transactions/asyncSqlCommitTransaction.gql

@@ -0,0 +1,5 @@
+mutation asyncSqlCommitTransaction($projectId: ID, $connectionId: ID!, $contextId: ID!) {
+  taskInfo: asyncSqlCommitTransaction(projectId: $projectId, connectionId: $connectionId, contextId: $contextId) {
+    ...AsyncTaskInfo
+  }
+}

webapp/packages/core-sdk/src/queries/transactions/asyncSqlRollbackTransaction.gql

@@ -0,0 +1,5 @@
+mutation asyncSqlRollbackTransaction($projectId: ID, $connectionId: ID!, $contextId: ID!) {
+  taskInfo: asyncSqlRollbackTransaction(projectId: $projectId, connectionId: $connectionId, contextId: $contextId) {
+    ...AsyncTaskInfo
+  }
+}

webapp/packages/core-sdk/src/queries/transactions/asyncSqlSetAutoCommit.gql

@@ -0,0 +1,5 @@
+mutation asyncSqlSetAutoCommit($projectId: ID, $connectionId: ID!, $contextId: ID!, $autoCommit: Boolean!) {
+  taskInfo: asyncSqlSetAutoCommit(projectId: $projectId, connectionId: $connectionId, contextId: $contextId, autoCommit: $autoCommit) {
+    ...AsyncTaskInfo
+  }
+}