source.dussan.org Git - vaadin-framework.git/blob

   1 /*
   2  * Copyright 2000-2021 Vaadin Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
   5  * use this file except in compliance with the License. You may obtain a copy of
   6  * the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  12  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  13  * License for the specific language governing permissions and limitations under
  14  * the License.
  15  */
  16 package com.vaadin.v7.data.util.sqlcontainer.query;
  17
  18 import java.io.Serializable;
  19 import java.sql.Connection;
  20 import java.sql.PreparedStatement;
  21 import java.sql.ResultSet;
  22 import java.sql.SQLException;
  23 import java.sql.Statement;
  24
  25 import com.vaadin.v7.data.util.sqlcontainer.connection.JDBCConnectionPool;
  26
  27 /**
  28  * Common base class for database query classes that handle connections and
  29  * transactions.
  30  *
  31  * @author Vaadin Ltd
  32  * @since 6.8.9
  33  *
  34  * @deprecated As of 8.0, no replacement available.
  35  */
  36 @Deprecated
  37 public abstract class AbstractTransactionalQuery implements Serializable {
  38
  39     private JDBCConnectionPool connectionPool;
  40     private transient Connection activeConnection;
  41
  42     AbstractTransactionalQuery() {
  43     }
  44
  45     AbstractTransactionalQuery(JDBCConnectionPool connectionPool) {
  46         this.connectionPool = connectionPool;
  47     }
  48
  49     /**
  50      * Reserves a connection with auto-commit off if no transaction is in
  51      * progress.
  52      *
  53      * @throws IllegalStateException
  54      *             if a transaction is already open
  55      * @throws SQLException
  56      *             if a connection could not be obtained or configured
  57      */
  58     public void beginTransaction()
  59             throws UnsupportedOperationException, SQLException {
  60         if (isInTransaction()) {
  61             throw new IllegalStateException("A transaction is already active!");
  62         }
  63         activeConnection = connectionPool.reserveConnection();
  64         activeConnection.setAutoCommit(false);
  65     }
  66
  67     /**
  68      * Commits (if not in auto-commit mode) and releases the active connection.
  69      *
  70      * @throws SQLException
  71      *             if not in a transaction managed by this query
  72      */
  73     public void commit() throws UnsupportedOperationException, SQLException {
  74         if (!isInTransaction()) {
  75             throw new SQLException("No active transaction");
  76         }
  77         if (!activeConnection.getAutoCommit()) {
  78             activeConnection.commit();
  79         }
  80         connectionPool.releaseConnection(activeConnection);
  81         activeConnection = null;
  82     }
  83
  84     /**
  85      * Rolls back and releases the active connection.
  86      *
  87      * @throws SQLException
  88      *             if not in a transaction managed by this query
  89      */
  90     public void rollback() throws UnsupportedOperationException, SQLException {
  91         if (!isInTransaction()) {
  92             throw new SQLException("No active transaction");
  93         }
  94         activeConnection.rollback();
  95         connectionPool.releaseConnection(activeConnection);
  96         activeConnection = null;
  97     }
  98
  99     /**
 100      * Check that a transaction is active.
 101      *
 102      * @throws SQLException
 103      *             if no active transaction
 104      */
 105     protected void ensureTransaction() throws SQLException {
 106         if (!isInTransaction()) {
 107             throw new SQLException("No active transaction!");
 108         }
 109     }
 110
 111     /**
 112      * Closes a statement and a resultset, then releases the connection if it is
 113      * not part of an active transaction. A failure in closing one of the
 114      * parameters does not prevent closing the rest.
 115      *
 116      * If the statement is a {@link PreparedStatement}, its parameters are
 117      * cleared prior to closing the statement.
 118      *
 119      * Although JDBC specification does state that closing a statement closes
 120      * its result set and closing a connection closes statements and result
 121      * sets, this method does try to close the result set and statement
 122      * explicitly whenever not null. This can guard against bugs in certain JDBC
 123      * drivers and reduce leaks in case e.g. closing the result set succeeds but
 124      * closing the statement or connection fails.
 125      *
 126      * @param conn
 127      *            the connection to release
 128      * @param statement
 129      *            the statement to close, may be null to skip closing
 130      * @param rs
 131      *            the result set to close, may be null to skip closing
 132      * @throws SQLException
 133      *             if closing the result set or the statement fails
 134      */
 135     protected void releaseConnection(Connection conn, Statement statement,
 136             ResultSet rs) throws SQLException {
 137         try {
 138             try {
 139                 if (null != rs) {
 140                     rs.close();
 141                 }
 142             } finally {
 143                 if (null != statement) {
 144                     if (statement instanceof PreparedStatement) {
 145                         try {
 146                             ((PreparedStatement) statement).clearParameters();
 147                         } catch (Exception e) {
 148                             // will be closed below anyway
 149                         }
 150                     }
 151                     statement.close();
 152                 }
 153             }
 154         } finally {
 155             releaseConnection(conn);
 156         }
 157     }
 158
 159     /**
 160      * Returns the currently active connection, reserves and returns a new
 161      * connection if no active connection.
 162      *
 163      * @return previously active or newly reserved connection
 164      * @throws SQLException
 165      */
 166     protected Connection getConnection() throws SQLException {
 167         if (activeConnection != null) {
 168             return activeConnection;
 169         }
 170         return connectionPool.reserveConnection();
 171     }
 172
 173     protected boolean isInTransaction() {
 174         return activeConnection != null;
 175     }
 176
 177     /**
 178      * Releases the connection if it is not part of an active transaction.
 179      *
 180      * @param conn
 181      *            the connection to release
 182      */
 183     private void releaseConnection(Connection conn) {
 184         if (conn != activeConnection && conn != null) {
 185             connectionPool.releaseConnection(conn);
 186         }
 187     }
 188 }