Source code

001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017package org.apache.commons.dbcp2;
018
019import java.io.InputStream;
020import java.io.Reader;
021import java.math.BigDecimal;
022import java.net.URL;
023import java.sql.Array;
024import java.sql.Blob;
025import java.sql.Clob;
026import java.sql.Connection;
027import java.sql.DatabaseMetaData;
028import java.sql.Date;
029import java.sql.Ref;
030import java.sql.ResultSet;
031import java.sql.RowId;
032import java.sql.SQLException;
033import java.sql.SQLFeatureNotSupportedException;
034import java.sql.SQLXML;
035import java.sql.Statement;
036import java.sql.Time;
037import java.sql.Timestamp;
038import java.util.concurrent.Executor;
039import java.util.logging.Logger;
040
041import javax.sql.CommonDataSource;
042
043/**
044 * Defines bridge methods to JDBC 4.1 (Java 7) methods to allow call sites to operate safely (without
045 * {@link AbstractMethodError}) when using a JDBC driver written for JDBC 4.0 (Java 6).
046 *
047 * @since 2.6.0
048 */
049public class Jdbc41Bridge {
050
051    /**
052     * Delegates to {@link Connection#abort(Executor)} without throwing a {@link AbstractMethodError}.
053     * <p>
054     * If the JDBC driver does not implement {@link Connection#abort(Executor)}, then call {@link Connection#close()}.
055     * </p>
056     *
057     * @param connection
058     *            the receiver
059     * @param executor
060     *            See {@link Connection#abort(Executor)}.
061     * @throws SQLException
062     *             See {@link Connection#abort(Executor)}.
063     * @see Connection#abort(Executor)
064     */
065    public static void abort(final Connection connection, final Executor executor) throws SQLException {
066        try {
067            connection.abort(executor);
068        } catch (final AbstractMethodError e) {
069            connection.close();
070        }
071    }
072
073    /**
074     * Delegates to {@link DatabaseMetaData#generatedKeyAlwaysReturned()} without throwing a
075     * {@link AbstractMethodError}.
076     * <p>
077     * If the JDBC driver does not implement {@link DatabaseMetaData#generatedKeyAlwaysReturned()}, then return false.
078     * </p>
079     *
080     * @param databaseMetaData
081     *            See {@link DatabaseMetaData#generatedKeyAlwaysReturned()}
082     * @return See {@link DatabaseMetaData#generatedKeyAlwaysReturned()}
083     * @throws SQLException
084     *             See {@link DatabaseMetaData#generatedKeyAlwaysReturned()}
085     * @see DatabaseMetaData#generatedKeyAlwaysReturned()
086     */
087    public static boolean generatedKeyAlwaysReturned(final DatabaseMetaData databaseMetaData) throws SQLException {
088        try {
089            return databaseMetaData.generatedKeyAlwaysReturned();
090        } catch (final AbstractMethodError e) {
091            // do nothing
092            return false;
093        }
094    }
095
096    /**
097     * Delegates to {@link Connection#getNetworkTimeout()} without throwing a {@link AbstractMethodError}.
098     * <p>
099     * If the JDBC driver does not implement {@link Connection#getNetworkTimeout()}, then return 0.
100     * </p>
101     *
102     * @param connection
103     *            the receiver
104     * @return See {@link Connection#getNetworkTimeout()}
105     * @throws SQLException
106     *             See {@link Connection#getNetworkTimeout()}
107     * @see Connection#getNetworkTimeout()
108     */
109    public static int getNetworkTimeout(final Connection connection) throws SQLException {
110        try {
111            return connection.getNetworkTimeout();
112        } catch (final AbstractMethodError e) {
113            return 0;
114        }
115    }
116
117    /**
118     * Delegates to {@link ResultSet#getObject(int, Class)} without throwing a {@link AbstractMethodError}.
119     * <p>
120     * If the JDBC driver does not implement {@link ResultSet#getObject(int, Class)}, then return 0.
121     * </p>
122     *
123     * @param <T>
124     *            See {@link ResultSet#getObject(int, Class)}
125     * @param resultSet
126     *            See {@link ResultSet#getObject(int, Class)}
127     * @param columnIndex
128     *            See {@link ResultSet#getObject(int, Class)}
129     * @param type
130     *            See {@link ResultSet#getObject(int, Class)}
131     * @return See {@link ResultSet#getObject(int, Class)}
132     * @throws SQLException
133     *             See {@link ResultSet#getObject(int, Class)}
134     * @see ResultSet#getObject(int, Class)
135     */
136    @SuppressWarnings("unchecked")
137    public static <T> T getObject(final ResultSet resultSet, final int columnIndex, final Class<T> type)
138            throws SQLException {
139        try {
140            return resultSet.getObject(columnIndex, type);
141        } catch (final AbstractMethodError e) {
142            if (type == String.class) {
143                return (T) resultSet.getString(columnIndex);
144            }
145            // Numbers
146            if (type == Integer.class) {
147                return (T) Integer.valueOf(resultSet.getInt(columnIndex));
148            }
149            if (type == Long.class) {
150                return (T) Long.valueOf(resultSet.getLong(columnIndex));
151            }
152            if (type == Double.class) {
153                return (T) Double.valueOf(resultSet.getDouble(columnIndex));
154            }
155            if (type == Float.class) {
156                return (T) Float.valueOf(resultSet.getFloat(columnIndex));
157            }
158            if (type == Short.class) {
159                return (T) Short.valueOf(resultSet.getShort(columnIndex));
160            }
161            if (type == BigDecimal.class) {
162                return (T) resultSet.getBigDecimal(columnIndex);
163            }
164            if (type == Byte.class) {
165                return (T) Byte.valueOf(resultSet.getByte(columnIndex));
166            }
167            // Dates
168            if (type == Date.class) {
169                return (T) resultSet.getDate(columnIndex);
170            }
171            if (type == Time.class) {
172                return (T) resultSet.getTime(columnIndex);
173            }
174            if (type == Timestamp.class) {
175                return (T) resultSet.getTimestamp(columnIndex);
176            }
177            // Streams
178            if (type == InputStream.class) {
179                return (T) resultSet.getBinaryStream(columnIndex);
180            }
181            if (type == Reader.class) {
182                return (T) resultSet.getCharacterStream(columnIndex);
183            }
184            // Other
185            if (type == Object.class) {
186                return (T) resultSet.getObject(columnIndex);
187            }
188            if (type == Boolean.class) {
189                return (T) Boolean.valueOf(resultSet.getBoolean(columnIndex));
190            }
191            if (type == Array.class) {
192                return (T) resultSet.getArray(columnIndex);
193            }
194            if (type == Blob.class) {
195                return (T) resultSet.getBlob(columnIndex);
196            }
197            if (type == Clob.class) {
198                return (T) resultSet.getClob(columnIndex);
199            }
200            if (type == Ref.class) {
201                return (T) resultSet.getRef(columnIndex);
202            }
203            if (type == RowId.class) {
204                return (T) resultSet.getRowId(columnIndex);
205            }
206            if (type == SQLXML.class) {
207                return (T) resultSet.getSQLXML(columnIndex);
208            }
209            if (type == URL.class) {
210                return (T) resultSet.getURL(columnIndex);
211            }
212            throw new SQLFeatureNotSupportedException(
213                    String.format("resultSet=%s, columnIndex=%,d, type=%s", resultSet, columnIndex, type));
214        }
215    }
216
217    /**
218     * Delegates to {@link ResultSet#getObject(String, Class)} without throwing a {@link AbstractMethodError}.
219     *
220     * @param <T>
221     *            See {@link ResultSet#getObject(String, Class)}
222     * @param resultSet
223     *            See {@link ResultSet#getObject(String, Class)}
224     * @param columnLabel
225     *            See {@link ResultSet#getObject(String, Class)}
226     * @param type
227     *            See {@link ResultSet#getObject(String, Class)}
228     * @return See {@link ResultSet#getObject(String, Class)}
229     * @throws SQLException
230     *             See {@link ResultSet#getObject(String, Class)}
231     * @see ResultSet#getObject(int, Class)
232     */
233    @SuppressWarnings("unchecked")
234    public static <T> T getObject(final ResultSet resultSet, final String columnLabel, final Class<T> type)
235            throws SQLException {
236        try {
237            return resultSet.getObject(columnLabel, type);
238        } catch (final AbstractMethodError e) {
239            // Numbers
240            if (type == Integer.class) {
241                return (T) Integer.valueOf(resultSet.getInt(columnLabel));
242            }
243            if (type == Long.class) {
244                return (T) Long.valueOf(resultSet.getLong(columnLabel));
245            }
246            if (type == Double.class) {
247                return (T) Double.valueOf(resultSet.getDouble(columnLabel));
248            }
249            if (type == Float.class) {
250                return (T) Float.valueOf(resultSet.getFloat(columnLabel));
251            }
252            if (type == Short.class) {
253                return (T) Short.valueOf(resultSet.getShort(columnLabel));
254            }
255            if (type == BigDecimal.class) {
256                return (T) resultSet.getBigDecimal(columnLabel);
257            }
258            if (type == Byte.class) {
259                return (T) Byte.valueOf(resultSet.getByte(columnLabel));
260            }
261            // Dates
262            if (type == Date.class) {
263                return (T) resultSet.getDate(columnLabel);
264            }
265            if (type == Time.class) {
266                return (T) resultSet.getTime(columnLabel);
267            }
268            if (type == Timestamp.class) {
269                return (T) resultSet.getTimestamp(columnLabel);
270            }
271            // Streams
272            if (type == InputStream.class) {
273                return (T) resultSet.getBinaryStream(columnLabel);
274            }
275            if (type == Reader.class) {
276                return (T) resultSet.getCharacterStream(columnLabel);
277            }
278            // Other
279            if (type == Object.class) {
280                return (T) resultSet.getObject(columnLabel);
281            }
282            if (type == Boolean.class) {
283                return (T) Boolean.valueOf(resultSet.getBoolean(columnLabel));
284            }
285            if (type == Array.class) {
286                return (T) resultSet.getArray(columnLabel);
287            }
288            if (type == Blob.class) {
289                return (T) resultSet.getBlob(columnLabel);
290            }
291            if (type == Clob.class) {
292                return (T) resultSet.getClob(columnLabel);
293            }
294            if (type == Ref.class) {
295                return (T) resultSet.getRef(columnLabel);
296            }
297            if (type == RowId.class) {
298                return (T) resultSet.getRowId(columnLabel);
299            }
300            if (type == SQLXML.class) {
301                return (T) resultSet.getSQLXML(columnLabel);
302            }
303            if (type == URL.class) {
304                return (T) resultSet.getURL(columnLabel);
305            }
306            throw new SQLFeatureNotSupportedException(
307                    String.format("resultSet=%s, columnLabel=%s, type=%s", resultSet, columnLabel, type));
308        }
309    }
310
311    /**
312     * Delegates to {@link DatabaseMetaData#getPseudoColumns(String, String, String, String)} without throwing a
313     * {@link AbstractMethodError}.
314     * <p>
315     * If the JDBC driver does not implement {@link DatabaseMetaData#getPseudoColumns(String, String, String, String)},
316     * then return null.
317     * </p>
318     *
319     * @param databaseMetaData
320     *            the receiver
321     * @param catalog
322     *            See {@link DatabaseMetaData#getPseudoColumns(String, String, String, String)}
323     * @param schemaPattern
324     *            See {@link DatabaseMetaData#getPseudoColumns(String, String, String, String)}
325     * @param tableNamePattern
326     *            See {@link DatabaseMetaData#getPseudoColumns(String, String, String, String)}
327     * @param columnNamePattern
328     *            See {@link DatabaseMetaData#getPseudoColumns(String, String, String, String)}
329     * @return See {@link DatabaseMetaData#getPseudoColumns(String, String, String, String)}
330     * @throws SQLException
331     *             See {@link DatabaseMetaData#getPseudoColumns(String, String, String, String)}
332     * @see DatabaseMetaData#getPseudoColumns(String, String, String, String)
333     */
334    public static ResultSet getPseudoColumns(final DatabaseMetaData databaseMetaData, final String catalog,
335            final String schemaPattern, final String tableNamePattern, final String columnNamePattern)
336            throws SQLException {
337        try {
338            return databaseMetaData.getPseudoColumns(catalog, schemaPattern, tableNamePattern, columnNamePattern);
339        } catch (final AbstractMethodError e) {
340            // do nothing
341            return null;
342        }
343    }
344
345    /**
346     * Delegates to {@link Connection#getSchema()} without throwing a {@link AbstractMethodError}.
347     * <p>
348     * If the JDBC driver does not implement {@link Connection#getSchema()}, then return null.
349     * </p>
350     *
351     * @param connection
352     *            the receiver
353     * @return null for a JDBC 4 driver or a value per {@link Connection#getSchema()}.
354     * @throws SQLException
355     *             See {@link Connection#getSchema()}.
356     * @see Connection#getSchema()
357     */
358    public static String getSchema(final Connection connection) throws SQLException {
359        try {
360            return connection.getSchema();
361        } catch (final AbstractMethodError e) {
362            // do nothing
363            return null;
364        }
365    }
366
367    /**
368     * Delegates to {@link Connection#setNetworkTimeout(Executor, int)} without throwing a {@link AbstractMethodError}.
369     * <p>
370     * If the JDBC driver does not implement {@link Connection#setNetworkTimeout(Executor, int)}, then do nothing.
371     * </p>
372     *
373     * @param connection
374     *            the receiver
375     * @param executor
376     *            See {@link Connection#setNetworkTimeout(Executor, int)}
377     * @param milliseconds
378     *            {@link Connection#setNetworkTimeout(Executor, int)}
379     * @throws SQLException
380     *             {@link Connection#setNetworkTimeout(Executor, int)}
381     * @see Connection#setNetworkTimeout(Executor, int)
382     */
383    public static void setNetworkTimeout(final Connection connection, final Executor executor, final int milliseconds)
384            throws SQLException {
385        try {
386            connection.setNetworkTimeout(executor, milliseconds);
387        } catch (final AbstractMethodError e) {
388            // do nothing
389        }
390    }
391
392    /**
393     * Delegates to {@link Connection#setSchema(String)} without throwing a {@link AbstractMethodError}.
394     * <p>
395     * If the JDBC driver does not implement {@link Connection#setSchema(String)}, then do nothing.
396     * </p>
397     *
398     * @param connection
399     *            the receiver
400     * @param schema
401     *            See {@link Connection#setSchema(String)}.
402     * @throws SQLException
403     *             See {@link Connection#setSchema(String)}.
404     * @see Connection#setSchema(String)
405     */
406    public static void setSchema(final Connection connection, final String schema) throws SQLException {
407        try {
408            connection.setSchema(schema);
409        } catch (final AbstractMethodError e) {
410            // do nothing
411        }
412    }
413
414    /**
415     * Delegates to {@link Statement#closeOnCompletion()} without throwing a {@link AbstractMethodError}.
416     * <p>
417     * If the JDBC driver does not implement {@link Statement#closeOnCompletion()}, then just check that the connection
418     * is closed to then throw a SQLException.
419     * </p>
420     *
421     * @param statement
422     *            See {@link Statement#closeOnCompletion()}
423     * @throws SQLException
424     *             See {@link Statement#closeOnCompletion()}
425     * @see Statement#closeOnCompletion()
426     */
427    public static void closeOnCompletion(final Statement statement) throws SQLException {
428        try {
429            statement.closeOnCompletion();
430        } catch (final AbstractMethodError e) {
431            if (statement.isClosed()) {
432                throw new SQLException("Statement closed");
433            }
434        }
435    }
436
437    /**
438     * Delegates to {@link Statement#isCloseOnCompletion()} without throwing a {@link AbstractMethodError}.
439     * <p>
440     * If the JDBC driver does not implement {@link Statement#isCloseOnCompletion()}, then just check that the
441     * connection is closed to then throw a SQLException.
442     * </p>
443     *
444     * @param statement
445     *            See {@link Statement#isCloseOnCompletion()}
446     * @return See {@link Statement#isCloseOnCompletion()}
447     * @throws SQLException
448     *             See {@link Statement#isCloseOnCompletion()}
449     * @see Statement#closeOnCompletion()
450     */
451    public static boolean isCloseOnCompletion(final Statement statement) throws SQLException {
452        try {
453            return statement.isCloseOnCompletion();
454        } catch (final AbstractMethodError e) {
455            if (statement.isClosed()) {
456                throw new SQLException("Statement closed");
457            }
458            return false;
459        }
460    }
461
462    /**
463     * Delegates to {@link CommonDataSource#getParentLogger()} without throwing a {@link AbstractMethodError}.
464     * <p>
465     * If the JDBC driver does not implement {@link CommonDataSource#getParentLogger()}, then return null.
466     * </p>
467     *
468     * @param commonDataSource
469     *            See {@link CommonDataSource#getParentLogger()}
470     * @return See {@link CommonDataSource#getParentLogger()}
471     * @throws SQLFeatureNotSupportedException
472     *             See {@link CommonDataSource#getParentLogger()}
473     */
474    public static Logger getParentLogger(final CommonDataSource commonDataSource) throws SQLFeatureNotSupportedException {
475        try {
476            return commonDataSource.getParentLogger();
477        } catch (final AbstractMethodError e) {
478            throw new SQLFeatureNotSupportedException("javax.sql.CommonDataSource#getParentLogger()");
479        }
480    }
481
482}