]> source.dussan.org Git - vaadin-framework.git/blob
7824959f0655c66a6cccb4e946184ee53794dd78
[vaadin-framework.git] /
1 /*
2  * Copyright 2000-2018 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 }