| /* |
| * Copyright (c) 2003, 2018 Oracle and/or its affiliates. All rights reserved. |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0, which is available at |
| * http://www.eclipse.org/legal/epl-2.0. |
| * |
| * This Source Code may also be made available under the following Secondary |
| * Licenses when the conditions for such availability set forth in the |
| * Eclipse Public License v. 2.0 are satisfied: GNU General Public License, |
| * version 2 with the GNU Classpath Exception, which is available at |
| * https://www.gnu.org/software/classpath/license.html. |
| * |
| * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 |
| */ |
| |
| package com.sun.jdbcra.spi; |
| |
| import jakarta.resource.ResourceException; |
| import jakarta.resource.spi.ConnectionRequestInfo; |
| import com.sun.jdbcra.spi.ConnectionManager; |
| import com.sun.jdbcra.util.SecurityUtils; |
| import jakarta.resource.spi.security.PasswordCredential; |
| import java.sql.DriverManager; |
| import com.sun.jdbcra.common.DataSourceSpec; |
| import com.sun.jdbcra.common.DataSourceObjectBuilder; |
| import java.sql.SQLException; |
| |
| import java.util.logging.Logger; |
| import java.util.logging.Level; |
| /** |
| * <code>ManagedConnectionFactory</code> implementation for Generic JDBC Connector. |
| * This class is extended by the DataSource specific <code>ManagedConnection</code> factories |
| * and the <code>ManagedConnectionFactory</code> for the <code>DriverManager</code>. |
| * |
| * @version 1.0, 02/08/03 |
| * @author Evani Sai Surya Kiran |
| */ |
| |
| public abstract class ManagedConnectionFactory implements jakarta.resource.spi.ManagedConnectionFactory, |
| java.io.Serializable { |
| |
| protected DataSourceSpec spec = new DataSourceSpec(); |
| protected transient DataSourceObjectBuilder dsObjBuilder; |
| |
| protected java.io.PrintWriter logWriter = null; |
| protected jakarta.resource.spi.ResourceAdapter ra = null; |
| |
| private static Logger _logger; |
| static { |
| _logger = Logger.getAnonymousLogger(); |
| } |
| private boolean debug = false; |
| /** |
| * Creates a Connection Factory instance. The <code>ConnectionManager</code> implementation |
| * of the resource adapter is used here. |
| * |
| * @return Generic JDBC Connector implementation of <code>javax.sql.DataSource</code> |
| */ |
| public Object createConnectionFactory() { |
| if(logWriter != null) { |
| logWriter.println("In createConnectionFactory()"); |
| } |
| com.sun.jdbcra.spi.DataSource cf = new com.sun.jdbcra.spi.DataSource( |
| (jakarta.resource.spi.ManagedConnectionFactory)this, null); |
| |
| return cf; |
| } |
| |
| /** |
| * Creates a Connection Factory instance. The <code>ConnectionManager</code> implementation |
| * of the application server is used here. |
| * |
| * @param cxManager <code>ConnectionManager</code> passed by the application server |
| * @return Generic JDBC Connector implementation of <code>javax.sql.DataSource</code> |
| */ |
| public Object createConnectionFactory(jakarta.resource.spi.ConnectionManager cxManager) { |
| if(logWriter != null) { |
| logWriter.println("In createConnectionFactory(jakarta.resource.spi.ConnectionManager cxManager)"); |
| } |
| com.sun.jdbcra.spi.DataSource cf = new com.sun.jdbcra.spi.DataSource( |
| (jakarta.resource.spi.ManagedConnectionFactory)this, cxManager); |
| return cf; |
| } |
| |
| /** |
| * Creates a new physical connection to the underlying EIS resource |
| * manager. |
| * |
| * @param subject <code>Subject</code> instance passed by the application server |
| * @param cxRequestInfo <code>ConnectionRequestInfo</code> which may be created |
| * as a result of the invocation <code>getConnection(user, password)</code> |
| * on the <code>DataSource</code> object |
| * @return <code>ManagedConnection</code> object created |
| * @throws ResourceException if there is an error in instantiating the |
| * <code>DataSource</code> object used for the |
| * creation of the <code>ManagedConnection</code> object |
| * @throws SecurityException if there ino <code>PasswordCredential</code> object |
| * satisfying this request |
| * @throws ResourceAllocationException if there is an error in allocating the |
| * physical connection |
| */ |
| public abstract jakarta.resource.spi.ManagedConnection createManagedConnection(javax.security.auth.Subject subject, |
| ConnectionRequestInfo cxRequestInfo) throws ResourceException; |
| |
| /** |
| * Check if this <code>ManagedConnectionFactory</code> is equal to |
| * another <code>ManagedConnectionFactory</code>. |
| * |
| * @param other <code>ManagedConnectionFactory</code> object for checking equality with |
| * @return true if the property sets of both the |
| * <code>ManagedConnectionFactory</code> objects are the same |
| * false otherwise |
| */ |
| public abstract boolean equals(Object other); |
| |
| /** |
| * Get the log writer for this <code>ManagedConnectionFactory</code> instance. |
| * |
| * @return <code>PrintWriter</code> associated with this <code>ManagedConnectionFactory</code> instance |
| * @see <code>setLogWriter</code> |
| */ |
| public java.io.PrintWriter getLogWriter() { |
| return logWriter; |
| } |
| |
| /** |
| * Get the <code>ResourceAdapter</code> for this <code>ManagedConnectionFactory</code> instance. |
| * |
| * @return <code>ResourceAdapter</code> associated with this <code>ManagedConnectionFactory</code> instance |
| * @see <code>setResourceAdapter</code> |
| */ |
| public jakarta.resource.spi.ResourceAdapter getResourceAdapter() { |
| if(logWriter != null) { |
| logWriter.println("In getResourceAdapter"); |
| } |
| return ra; |
| } |
| |
| /** |
| * Returns the hash code for this <code>ManagedConnectionFactory</code>. |
| * |
| * @return hash code for this <code>ManagedConnectionFactory</code> |
| */ |
| public int hashCode(){ |
| if(logWriter != null) { |
| logWriter.println("In hashCode"); |
| } |
| return spec.hashCode(); |
| } |
| |
| /** |
| * Returns a matched <code>ManagedConnection</code> from the candidate |
| * set of <code>ManagedConnection</code> objects. |
| * |
| * @param connectionSet <code>Set</code> of <code>ManagedConnection</code> |
| * objects passed by the application server |
| * @param subject passed by the application server |
| * for retrieving information required for matching |
| * @param cxRequestInfo <code>ConnectionRequestInfo</code> passed by the application server |
| * for retrieving information required for matching |
| * @return <code>ManagedConnection</code> that is the best match satisfying this request |
| * @throws ResourceException if there is an error accessing the <code>Subject</code> |
| * parameter or the <code>Set</code> of <code>ManagedConnection</code> |
| * objects passed by the application server |
| */ |
| public jakarta.resource.spi.ManagedConnection matchManagedConnections(java.util.Set connectionSet, |
| javax.security.auth.Subject subject, ConnectionRequestInfo cxRequestInfo) throws ResourceException { |
| if(logWriter != null) { |
| logWriter.println("In matchManagedConnections"); |
| } |
| |
| if(connectionSet == null) { |
| return null; |
| } |
| |
| PasswordCredential pc = SecurityUtils.getPasswordCredential(this, subject, cxRequestInfo); |
| |
| java.util.Iterator iter = connectionSet.iterator(); |
| com.sun.jdbcra.spi.ManagedConnection mc = null; |
| while(iter.hasNext()) { |
| try { |
| mc = (com.sun.jdbcra.spi.ManagedConnection) iter.next(); |
| } catch(java.util.NoSuchElementException nsee) { |
| _logger.log(Level.SEVERE, "jdbc.exc_iter"); |
| throw new ResourceException(nsee.getMessage()); |
| } |
| if(pc == null && this.equals(mc.getManagedConnectionFactory())) { |
| //GJCINT |
| try { |
| isValid(mc); |
| return mc; |
| } catch(ResourceException re) { |
| _logger.log(Level.SEVERE, "jdbc.exc_re", re); |
| mc.connectionErrorOccurred(re, null); |
| } |
| } else if(SecurityUtils.isPasswordCredentialEqual(pc, mc.getPasswordCredential()) == true) { |
| //GJCINT |
| try { |
| isValid(mc); |
| return mc; |
| } catch(ResourceException re) { |
| _logger.log(Level.SEVERE, "jdbc.re"); |
| mc.connectionErrorOccurred(re, null); |
| } |
| } |
| } |
| return null; |
| } |
| |
| //GJCINT |
| /** |
| * Checks if a <code>ManagedConnection</code> is to be validated or not |
| * and validates it or returns. |
| * |
| * @param mc <code>ManagedConnection</code> to be validated |
| * @throws ResourceException if the connection is not valid or |
| * if validation method is not proper |
| */ |
| void isValid(com.sun.jdbcra.spi.ManagedConnection mc) throws ResourceException { |
| |
| if(mc.isTransactionInProgress()) { |
| return; |
| } |
| |
| boolean connectionValidationRequired = |
| (new Boolean(spec.getDetail(DataSourceSpec.CONNECTIONVALIDATIONREQUIRED).toLowerCase())).booleanValue(); |
| if( connectionValidationRequired == false || mc == null) { |
| return; |
| } |
| |
| |
| String validationMethod = spec.getDetail(DataSourceSpec.VALIDATIONMETHOD).toLowerCase(); |
| |
| mc.checkIfValid(); |
| /** |
| * The above call checks if the actual physical connection |
| * is usable or not. |
| */ |
| java.sql.Connection con = mc.getActualConnection(); |
| |
| if(validationMethod.equals("auto-commit") == true) { |
| isValidByAutoCommit(con); |
| } else if(validationMethod.equalsIgnoreCase("meta-data") == true) { |
| isValidByMetaData(con); |
| } else if(validationMethod.equalsIgnoreCase("table") == true) { |
| isValidByTableQuery(con, spec.getDetail(DataSourceSpec.VALIDATIONTABLENAME)); |
| } else { |
| throw new ResourceException("The validation method is not proper"); |
| } |
| } |
| |
| /** |
| * Checks if a <code>java.sql.Connection</code> is valid or not |
| * by checking its auto commit property. |
| * |
| * @param con <code>java.sql.Connection</code> to be validated |
| * @throws ResourceException if the connection is not valid |
| */ |
| protected void isValidByAutoCommit(java.sql.Connection con) throws ResourceException { |
| if(con == null) { |
| throw new ResourceException("The connection is not valid as " |
| + "the connection is null"); |
| } |
| |
| try { |
| // Notice that using something like |
| // dbCon.setAutoCommit(dbCon.getAutoCommit()) will cause problems with |
| // some drivers like sybase |
| // We do not validate connections that are already enlisted |
| //in a transaction |
| // We cycle autocommit to true and false to by-pass drivers that |
| // might cache the call to set autocomitt |
| // Also notice that some XA data sources will throw and exception if |
| // you try to call setAutoCommit, for them this method is not recommended |
| |
| boolean ac = con.getAutoCommit(); |
| if (ac) { |
| con.setAutoCommit(false); |
| } else { |
| con.rollback(); // prevents uncompleted transaction exceptions |
| con.setAutoCommit(true); |
| } |
| |
| con.setAutoCommit(ac); |
| |
| } catch(Exception sqle) { |
| _logger.log(Level.SEVERE, "jdbc.exc_autocommit"); |
| throw new ResourceException(sqle.getMessage()); |
| } |
| } |
| |
| /** |
| * Checks if a <code>java.sql.Connection</code> is valid or not |
| * by checking its meta data. |
| * |
| * @param con <code>java.sql.Connection</code> to be validated |
| * @throws ResourceException if the connection is not valid |
| */ |
| protected void isValidByMetaData(java.sql.Connection con) throws ResourceException { |
| if(con == null) { |
| throw new ResourceException("The connection is not valid as " |
| + "the connection is null"); |
| } |
| |
| try { |
| java.sql.DatabaseMetaData dmd = con.getMetaData(); |
| } catch(Exception sqle) { |
| _logger.log(Level.SEVERE, "jdbc.exc_md"); |
| throw new ResourceException("The connection is not valid as " |
| + "getting the meta data failed: " + sqle.getMessage()); |
| } |
| } |
| |
| /** |
| * Checks if a <code>java.sql.Connection</code> is valid or not |
| * by querying a table. |
| * |
| * @param con <code>java.sql.Connection</code> to be validated |
| * @param tableName table which should be queried |
| * @throws ResourceException if the connection is not valid |
| */ |
| protected void isValidByTableQuery(java.sql.Connection con, |
| String tableName) throws ResourceException { |
| if(con == null) { |
| throw new ResourceException("The connection is not valid as " |
| + "the connection is null"); |
| } |
| |
| try { |
| java.sql.Statement stmt = con.createStatement(); |
| java.sql.ResultSet rs = stmt.executeQuery("SELECT * FROM " + tableName); |
| } catch(Exception sqle) { |
| _logger.log(Level.SEVERE, "jdbc.exc_execute"); |
| throw new ResourceException("The connection is not valid as " |
| + "querying the table " + tableName + " failed: " + sqle.getMessage()); |
| } |
| } |
| |
| /** |
| * Sets the isolation level specified in the <code>ConnectionRequestInfo</code> |
| * for the <code>ManagedConnection</code> passed. |
| * |
| * @param mc <code>ManagedConnection</code> |
| * @throws ResourceException if the isolation property is invalid |
| * or if the isolation cannot be set over the connection |
| */ |
| protected void setIsolation(com.sun.jdbcra.spi.ManagedConnection mc) throws ResourceException { |
| |
| java.sql.Connection con = mc.getActualConnection(); |
| if(con == null) { |
| return; |
| } |
| |
| String tranIsolation = spec.getDetail(DataSourceSpec.TRANSACTIONISOLATION); |
| if(tranIsolation != null && tranIsolation.equals("") == false) { |
| int tranIsolationInt = getTransactionIsolationInt(tranIsolation); |
| try { |
| con.setTransactionIsolation(tranIsolationInt); |
| } catch(java.sql.SQLException sqle) { |
| _logger.log(Level.SEVERE, "jdbc.exc_tx_level"); |
| throw new ResourceException("The transaction isolation could " |
| + "not be set: " + sqle.getMessage()); |
| } |
| } |
| } |
| |
| /** |
| * Resets the isolation level for the <code>ManagedConnection</code> passed. |
| * If the transaction level is to be guaranteed to be the same as the one |
| * present when this <code>ManagedConnection</code> was created, as specified |
| * by the <code>ConnectionRequestInfo</code> passed, it sets the transaction |
| * isolation level from the <code>ConnectionRequestInfo</code> passed. Else, |
| * it sets it to the transaction isolation passed. |
| * |
| * @param mc <code>ManagedConnection</code> |
| * @param tranIsol int |
| * @throws ResourceException if the isolation property is invalid |
| * or if the isolation cannot be set over the connection |
| */ |
| void resetIsolation(com.sun.jdbcra.spi.ManagedConnection mc, int tranIsol) throws ResourceException { |
| |
| java.sql.Connection con = mc.getActualConnection(); |
| if(con == null) { |
| return; |
| } |
| |
| String tranIsolation = spec.getDetail(DataSourceSpec.TRANSACTIONISOLATION); |
| if(tranIsolation != null && tranIsolation.equals("") == false) { |
| String guaranteeIsolationLevel = spec.getDetail(DataSourceSpec.GUARANTEEISOLATIONLEVEL); |
| |
| if(guaranteeIsolationLevel != null && guaranteeIsolationLevel.equals("") == false) { |
| boolean guarantee = (new Boolean(guaranteeIsolationLevel.toLowerCase())).booleanValue(); |
| |
| if(guarantee) { |
| int tranIsolationInt = getTransactionIsolationInt(tranIsolation); |
| try { |
| if(tranIsolationInt != con.getTransactionIsolation()) { |
| con.setTransactionIsolation(tranIsolationInt); |
| } |
| } catch(java.sql.SQLException sqle) { |
| _logger.log(Level.SEVERE, "jdbc.exc_tx_level"); |
| throw new ResourceException("The isolation level could not be set: " |
| + sqle.getMessage()); |
| } |
| } else { |
| try { |
| if(tranIsol != con.getTransactionIsolation()) { |
| con.setTransactionIsolation(tranIsol); |
| } |
| } catch(java.sql.SQLException sqle) { |
| _logger.log(Level.SEVERE, "jdbc.exc_tx_level"); |
| throw new ResourceException("The isolation level could not be set: " |
| + sqle.getMessage()); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Gets the integer equivalent of the string specifying |
| * the transaction isolation. |
| * |
| * @param tranIsolation string specifying the isolation level |
| * @return tranIsolationInt the <code>java.sql.Connection</code> constant |
| * for the string specifying the isolation. |
| */ |
| private int getTransactionIsolationInt(String tranIsolation) throws ResourceException { |
| if(tranIsolation.equalsIgnoreCase("read-uncommitted")) { |
| return java.sql.Connection.TRANSACTION_READ_UNCOMMITTED; |
| } else if(tranIsolation.equalsIgnoreCase("read-committed")) { |
| return java.sql.Connection.TRANSACTION_READ_COMMITTED; |
| } else if(tranIsolation.equalsIgnoreCase("repeatable-read")) { |
| return java.sql.Connection.TRANSACTION_REPEATABLE_READ; |
| } else if(tranIsolation.equalsIgnoreCase("serializable")) { |
| return java.sql.Connection.TRANSACTION_SERIALIZABLE; |
| } else { |
| throw new ResourceException("Invalid transaction isolation; the transaction " |
| + "isolation level can be empty or any of the following: " |
| + "read-uncommitted, read-committed, repeatable-read, serializable"); |
| } |
| } |
| |
| /** |
| * Set the log writer for this <code>ManagedConnectionFactory</code> instance. |
| * |
| * @param out <code>PrintWriter</code> passed by the application server |
| * @see <code>getLogWriter</code> |
| */ |
| public void setLogWriter(java.io.PrintWriter out) { |
| logWriter = out; |
| } |
| |
| /** |
| * Set the associated <code>ResourceAdapter</code> JavaBean. |
| * |
| * @param ra <code>ResourceAdapter</code> associated with this |
| * <code>ManagedConnectionFactory</code> instance |
| * @see <code>getResourceAdapter</code> |
| */ |
| public void setResourceAdapter(jakarta.resource.spi.ResourceAdapter ra) { |
| this.ra = ra; |
| } |
| |
| /** |
| * Sets the user name |
| * |
| * @param user <code>String</code> |
| */ |
| public void setUser(String user) { |
| spec.setDetail(DataSourceSpec.USERNAME, user); |
| } |
| |
| /** |
| * Gets the user name |
| * |
| * @return user |
| */ |
| public String getUser() { |
| return spec.getDetail(DataSourceSpec.USERNAME); |
| } |
| |
| /** |
| * Sets the user name |
| * |
| * @param user <code>String</code> |
| */ |
| public void setuser(String user) { |
| spec.setDetail(DataSourceSpec.USERNAME, user); |
| } |
| |
| /** |
| * Gets the user name |
| * |
| * @return user |
| */ |
| public String getuser() { |
| return spec.getDetail(DataSourceSpec.USERNAME); |
| } |
| |
| /** |
| * Sets the password |
| * |
| * @param passwd <code>String</code> |
| */ |
| public void setPassword(String passwd) { |
| spec.setDetail(DataSourceSpec.PASSWORD, passwd); |
| } |
| |
| /** |
| * Gets the password |
| * |
| * @return passwd |
| */ |
| public String getPassword() { |
| return spec.getDetail(DataSourceSpec.PASSWORD); |
| } |
| |
| /** |
| * Sets the password |
| * |
| * @param passwd <code>String</code> |
| */ |
| public void setpassword(String passwd) { |
| spec.setDetail(DataSourceSpec.PASSWORD, passwd); |
| } |
| |
| /** |
| * Gets the password |
| * |
| * @return passwd |
| */ |
| public String getpassword() { |
| return spec.getDetail(DataSourceSpec.PASSWORD); |
| } |
| |
| /** |
| * Sets the class name of the data source |
| * |
| * @param className <code>String</code> |
| */ |
| public void setClassName(String className) { |
| spec.setDetail(DataSourceSpec.CLASSNAME, className); |
| } |
| |
| /** |
| * Gets the class name of the data source |
| * |
| * @return className |
| */ |
| public String getClassName() { |
| return spec.getDetail(DataSourceSpec.CLASSNAME); |
| } |
| |
| /** |
| * Sets the class name of the data source |
| * |
| * @param className <code>String</code> |
| */ |
| public void setclassName(String className) { |
| spec.setDetail(DataSourceSpec.CLASSNAME, className); |
| } |
| |
| /** |
| * Gets the class name of the data source |
| * |
| * @return className |
| */ |
| public String getclassName() { |
| return spec.getDetail(DataSourceSpec.CLASSNAME); |
| } |
| |
| /** |
| * Sets if connection validation is required or not |
| * |
| * @param conVldReq <code>String</code> |
| */ |
| public void setConnectionValidationRequired(String conVldReq) { |
| spec.setDetail(DataSourceSpec.CONNECTIONVALIDATIONREQUIRED, conVldReq); |
| } |
| |
| /** |
| * Returns if connection validation is required or not |
| * |
| * @return connection validation requirement |
| */ |
| public String getConnectionValidationRequired() { |
| return spec.getDetail(DataSourceSpec.CONNECTIONVALIDATIONREQUIRED); |
| } |
| |
| /** |
| * Sets if connection validation is required or not |
| * |
| * @param conVldReq <code>String</code> |
| */ |
| public void setconnectionValidationRequired(String conVldReq) { |
| spec.setDetail(DataSourceSpec.CONNECTIONVALIDATIONREQUIRED, conVldReq); |
| } |
| |
| /** |
| * Returns if connection validation is required or not |
| * |
| * @return connection validation requirement |
| */ |
| public String getconnectionValidationRequired() { |
| return spec.getDetail(DataSourceSpec.CONNECTIONVALIDATIONREQUIRED); |
| } |
| |
| /** |
| * Sets the validation method required |
| * |
| * @param validationMethod <code>String</code> |
| */ |
| public void setValidationMethod(String validationMethod) { |
| spec.setDetail(DataSourceSpec.VALIDATIONMETHOD, validationMethod); |
| } |
| |
| /** |
| * Returns the connection validation method type |
| * |
| * @return validation method |
| */ |
| public String getValidationMethod() { |
| return spec.getDetail(DataSourceSpec.VALIDATIONMETHOD); |
| } |
| |
| /** |
| * Sets the validation method required |
| * |
| * @param validationMethod <code>String</code> |
| */ |
| public void setvalidationMethod(String validationMethod) { |
| spec.setDetail(DataSourceSpec.VALIDATIONMETHOD, validationMethod); |
| } |
| |
| /** |
| * Returns the connection validation method type |
| * |
| * @return validation method |
| */ |
| public String getvalidationMethod() { |
| return spec.getDetail(DataSourceSpec.VALIDATIONMETHOD); |
| } |
| |
| /** |
| * Sets the table checked for during validation |
| * |
| * @param table <code>String</code> |
| */ |
| public void setValidationTableName(String table) { |
| spec.setDetail(DataSourceSpec.VALIDATIONTABLENAME, table); |
| } |
| |
| /** |
| * Returns the table checked for during validation |
| * |
| * @return table |
| */ |
| public String getValidationTableName() { |
| return spec.getDetail(DataSourceSpec.VALIDATIONTABLENAME); |
| } |
| |
| /** |
| * Sets the table checked for during validation |
| * |
| * @param table <code>String</code> |
| */ |
| public void setvalidationTableName(String table) { |
| spec.setDetail(DataSourceSpec.VALIDATIONTABLENAME, table); |
| } |
| |
| /** |
| * Returns the table checked for during validation |
| * |
| * @return table |
| */ |
| public String getvalidationTableName() { |
| return spec.getDetail(DataSourceSpec.VALIDATIONTABLENAME); |
| } |
| |
| /** |
| * Sets the transaction isolation level |
| * |
| * @param trnIsolation <code>String</code> |
| */ |
| public void setTransactionIsolation(String trnIsolation) { |
| spec.setDetail(DataSourceSpec.TRANSACTIONISOLATION, trnIsolation); |
| } |
| |
| /** |
| * Returns the transaction isolation level |
| * |
| * @return transaction isolation level |
| */ |
| public String getTransactionIsolation() { |
| return spec.getDetail(DataSourceSpec.TRANSACTIONISOLATION); |
| } |
| |
| /** |
| * Sets the transaction isolation level |
| * |
| * @param trnIsolation <code>String</code> |
| */ |
| public void settransactionIsolation(String trnIsolation) { |
| spec.setDetail(DataSourceSpec.TRANSACTIONISOLATION, trnIsolation); |
| } |
| |
| /** |
| * Returns the transaction isolation level |
| * |
| * @return transaction isolation level |
| */ |
| public String gettransactionIsolation() { |
| return spec.getDetail(DataSourceSpec.TRANSACTIONISOLATION); |
| } |
| |
| /** |
| * Sets if the transaction isolation level is to be guaranteed |
| * |
| * @param guaranteeIsolation <code>String</code> |
| */ |
| public void setGuaranteeIsolationLevel(String guaranteeIsolation) { |
| spec.setDetail(DataSourceSpec.GUARANTEEISOLATIONLEVEL, guaranteeIsolation); |
| } |
| |
| /** |
| * Returns the transaction isolation level |
| * |
| * @return isolation level guarantee |
| */ |
| public String getGuaranteeIsolationLevel() { |
| return spec.getDetail(DataSourceSpec.GUARANTEEISOLATIONLEVEL); |
| } |
| |
| /** |
| * Sets if the transaction isolation level is to be guaranteed |
| * |
| * @param guaranteeIsolation <code>String</code> |
| */ |
| public void setguaranteeIsolationLevel(String guaranteeIsolation) { |
| spec.setDetail(DataSourceSpec.GUARANTEEISOLATIONLEVEL, guaranteeIsolation); |
| } |
| |
| /** |
| * Returns the transaction isolation level |
| * |
| * @return isolation level guarantee |
| */ |
| public String getguaranteeIsolationLevel() { |
| return spec.getDetail(DataSourceSpec.GUARANTEEISOLATIONLEVEL); |
| } |
| |
| } |
