add various methods

cloneConnection, createTemporaryOrPrivateConnection,
closeConnection, abortConnection, getSchema, getUser,
isSupported

Author: PhilippSalvisberg

sqldev/src/main/java/org/utplsql/sqldev/model/DatabaseTools.java

@@ -21,11 +21,14 @@
 
 import javax.sql.DataSource;
 
+import org.springframework.core.task.SimpleAsyncTaskExecutor;
 import org.utplsql.sqldev.exception.GenericDatabaseAccessException;
+import org.utplsql.sqldev.exception.GenericRuntimeException;
 
 import oracle.dbtools.raptor.navigator.db.DatabaseConnection;
 import oracle.dbtools.raptor.utils.Connections;
 import oracle.javatools.db.DBException;
+import oracle.jdeveloper.db.ConnectionException;
 
 public class DatabaseTools {
     // do not instantiate this class
@@ -59,11 +62,112 @@ public static Connection getConnection(String connectionName) {
         }
     }
 
+    public static Connection cloneConnection(String connectionName) {
+        final Connection conn = getConnection(connectionName);
+        try {
+            return Connections.getInstance().cloneConnection(conn);
+        } catch (ConnectionException e) {
+            final String msg = "Error cloning connection " + connectionName + ".";
+            throw new GenericDatabaseAccessException(msg, e);
+        }
+    }
+    
+    private static String createTemporaryConnection(String connectionName) {
+        try {
+            return Connections.getInstance().createTemporaryConnection(connectionName);
+        } catch (Throwable e) {
+            final String msg = "Error creating temporary connection based on " + connectionName + ".";
+            throw new GenericDatabaseAccessException(msg, e);
+        }
+    }
+    
+    private static String createPrivateConnection(String connectionName) {
+        try {
+            return Connections.getInstance().createPrivateConnection(connectionName);
+        } catch (Throwable e) {
+            final String msg = "Error creating private connection based on " + connectionName + ".";
+            throw new GenericDatabaseAccessException(msg, e);
+        }
+    }
+    
+    public static String createTemporaryOrPrivateConnection(String connectionName) {
+        // Private connections are closed in SQL Developer < 17.4.0 when the worksheet
+        // is closed, but in SQL Developer > 17.4.0 private connections are not closed.
+        // Temporary connections have been introduced in SQL Developer 17.4.0. They will
+        // be always closed, when a worksheet is closed.
+        // Hence we try to use temporary connections whenever possible. See also
+        // https://github.com/utPLSQL/utPLSQL-SQLDeveloper/issues/47 .
+        try {
+            return createTemporaryConnection(connectionName);
+        } catch (GenericDatabaseAccessException e) {
+            return createPrivateConnection(connectionName);
+        }
+    }
+    
     public static boolean isConnectionClosed(Connection conn) {
         try {
             return conn.isClosed();
         } catch (SQLException e) {
             throw new GenericDatabaseAccessException("Error getting status of connection.", e);
         }
     }
+
+    public static void closeConnection(Connection conn) {
+        if (!isConnectionClosed(conn)) {
+            try {
+                conn.close();
+            } catch (SQLException e) {
+                throw new GenericDatabaseAccessException("Could not close connection.");
+            }
+        }
+    }
+    
+    public static void abortConnection(Connection conn) {
+        final SimpleAsyncTaskExecutor taskExecutor = new SimpleAsyncTaskExecutor();
+        try {
+            conn.abort(taskExecutor);
+        } catch (SQLException e) {
+            throw new GenericDatabaseAccessException("Could not abort connection.");
+        }
+    }
+    
+    public static String getSchema(Connection conn) {
+        try {
+            return conn.getSchema();
+        } catch (SQLException e) {
+            throw new GenericRuntimeException("Error getting schema name of connection.", e);
+        }
+    }
+
+    public static String getUser(Connection conn) {
+        try {
+            return conn.getMetaData().getUserName();
+        } catch (SQLException e) {
+            throw new GenericRuntimeException("Error getting user name of connection.", e);
+        }
+    }   
+    
+    public static String getSchema(DatabaseConnection conn) {
+        return getSchema(getConnection(conn));
+    }
+
+    
+    public static String getSchema(String connectionName) {
+        return getSchema(getConnection(connectionName));
+    }
+    
+    public static boolean isSupported(final Connection conn) {
+        try {
+            boolean ret = false;
+            if (conn != null && conn.getMetaData().getDatabaseProductName().startsWith("Oracle")
+                    && (conn.getMetaData().getDatabaseMajorVersion() == 11
+                            && conn.getMetaData().getDatabaseMinorVersion() >= 2
+                            || conn.getMetaData().getDatabaseMajorVersion() > 11)) {
+                ret = true;
+            }
+            return ret;
+        } catch (SQLException e) {
+            throw new GenericDatabaseAccessException("Error while getting product version of connection.", e);
+        }
+    }
 }