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 */
017
018package org.apache.commons.dbcp2;
019
020import java.io.InputStream;
021import java.io.Reader;
022import java.math.BigDecimal;
023import java.sql.Array;
024import java.sql.Blob;
025import java.sql.Clob;
026import java.sql.Date;
027import java.sql.NClob;
028import java.sql.PreparedStatement;
029import java.sql.Ref;
030import java.sql.ResultSet;
031import java.sql.ResultSetMetaData;
032import java.sql.RowId;
033import java.sql.SQLException;
034import java.sql.SQLType;
035import java.sql.SQLXML;
036import java.sql.Statement;
037import java.sql.Time;
038import java.sql.Timestamp;
039import java.util.Calendar;
040
041/**
042 * A base delegating implementation of {@link PreparedStatement}.
043 * <p>
044 * All of the methods from the {@link PreparedStatement} interface simply check to see that the
045 * {@link PreparedStatement} is active, and call the corresponding method on the "delegate" provided in my constructor.
046 * <p>
047 * Extends AbandonedTrace to implement Statement tracking and logging of code which created the Statement. Tracking the
048 * Statement ensures that the Connection which created it can close any open Statement's on Connection close.
049 *
050 * @since 2.0
051 */
052public class DelegatingPreparedStatement extends DelegatingStatement implements PreparedStatement {
053
054    /**
055     * Create a wrapper for the Statement which traces this Statement to the Connection which created it and the code
056     * which created it.
057     *
058     * @param statement
059     *            the {@link PreparedStatement} to delegate all calls to.
060     * @param connection
061     *            the {@link DelegatingConnection} that created this statement.
062     */
063    public DelegatingPreparedStatement(final DelegatingConnection<?> connection, final PreparedStatement statement) {
064        super(connection, statement);
065    }
066
067    @Override
068    public void addBatch() throws SQLException {
069        checkOpen();
070        try {
071            getDelegatePreparedStatement().addBatch();
072        } catch (final SQLException e) {
073            handleException(e);
074        }
075    }
076
077    @Override
078    public void clearParameters() throws SQLException {
079        checkOpen();
080        try {
081            getDelegatePreparedStatement().clearParameters();
082        } catch (final SQLException e) {
083            handleException(e);
084        }
085    }
086
087    @Override
088    public boolean execute() throws SQLException {
089        checkOpen();
090        if (getConnectionInternal() != null) {
091            getConnectionInternal().setLastUsed();
092        }
093        try {
094            return getDelegatePreparedStatement().execute();
095        } catch (final SQLException e) {
096            handleException(e);
097            return false;
098        }
099    }
100
101    /**
102     * @since 2.5.0
103     */
104    @Override
105    public long executeLargeUpdate() throws SQLException {
106        checkOpen();
107        try {
108            return getDelegatePreparedStatement().executeLargeUpdate();
109        } catch (final SQLException e) {
110            handleException(e);
111            return 0;
112        }
113    }
114
115    @Override
116    public ResultSet executeQuery() throws SQLException {
117        checkOpen();
118        if (getConnectionInternal() != null) {
119            getConnectionInternal().setLastUsed();
120        }
121        try {
122            return DelegatingResultSet.wrapResultSet(this, getDelegatePreparedStatement().executeQuery());
123        } catch (final SQLException e) {
124            handleException(e);
125            throw new AssertionError();
126        }
127    }
128
129    @Override
130    public int executeUpdate() throws SQLException {
131        checkOpen();
132        if (getConnectionInternal() != null) {
133            getConnectionInternal().setLastUsed();
134        }
135        try {
136            return getDelegatePreparedStatement().executeUpdate();
137        } catch (final SQLException e) {
138            handleException(e);
139            return 0;
140        }
141    }
142
143    private PreparedStatement getDelegatePreparedStatement() {
144        return (PreparedStatement) getDelegate();
145    }
146
147    @Override
148    public ResultSetMetaData getMetaData() throws SQLException {
149        checkOpen();
150        try {
151            return getDelegatePreparedStatement().getMetaData();
152        } catch (final SQLException e) {
153            handleException(e);
154            throw new AssertionError();
155        }
156    }
157
158    @Override
159    public java.sql.ParameterMetaData getParameterMetaData() throws SQLException {
160        checkOpen();
161        try {
162            return getDelegatePreparedStatement().getParameterMetaData();
163        } catch (final SQLException e) {
164            handleException(e);
165            throw new AssertionError();
166        }
167    }
168
169    @Override
170    public void setArray(final int i, final Array x) throws SQLException {
171        checkOpen();
172        try {
173            getDelegatePreparedStatement().setArray(i, x);
174        } catch (final SQLException e) {
175            handleException(e);
176        }
177    }
178
179    @Override
180    public void setAsciiStream(final int parameterIndex, final InputStream inputStream) throws SQLException {
181        checkOpen();
182        try {
183            getDelegatePreparedStatement().setAsciiStream(parameterIndex, inputStream);
184        } catch (final SQLException e) {
185            handleException(e);
186        }
187    }
188
189    @Override
190    public void setAsciiStream(final int parameterIndex, final InputStream x, final int length) throws SQLException {
191        checkOpen();
192        try {
193            getDelegatePreparedStatement().setAsciiStream(parameterIndex, x, length);
194        } catch (final SQLException e) {
195            handleException(e);
196        }
197    }
198
199    @Override
200    public void setAsciiStream(final int parameterIndex, final InputStream inputStream, final long length)
201            throws SQLException {
202        checkOpen();
203        try {
204            getDelegatePreparedStatement().setAsciiStream(parameterIndex, inputStream, length);
205        } catch (final SQLException e) {
206            handleException(e);
207        }
208    }
209
210    @Override
211    public void setBigDecimal(final int parameterIndex, final BigDecimal x) throws SQLException {
212        checkOpen();
213        try {
214            getDelegatePreparedStatement().setBigDecimal(parameterIndex, x);
215        } catch (final SQLException e) {
216            handleException(e);
217        }
218    }
219
220    @Override
221    public void setBinaryStream(final int parameterIndex, final InputStream inputStream) throws SQLException {
222        checkOpen();
223        try {
224            getDelegatePreparedStatement().setBinaryStream(parameterIndex, inputStream);
225        } catch (final SQLException e) {
226            handleException(e);
227        }
228    }
229
230    @Override
231    public void setBinaryStream(final int parameterIndex, final InputStream x, final int length) throws SQLException {
232        checkOpen();
233        try {
234            getDelegatePreparedStatement().setBinaryStream(parameterIndex, x, length);
235        } catch (final SQLException e) {
236            handleException(e);
237        }
238    }
239
240    @Override
241    public void setBinaryStream(final int parameterIndex, final InputStream inputStream, final long length)
242            throws SQLException {
243        checkOpen();
244        try {
245            getDelegatePreparedStatement().setBinaryStream(parameterIndex, inputStream, length);
246        } catch (final SQLException e) {
247            handleException(e);
248        }
249    }
250
251    @Override
252    public void setBlob(final int i, final Blob x) throws SQLException {
253        checkOpen();
254        try {
255            getDelegatePreparedStatement().setBlob(i, x);
256        } catch (final SQLException e) {
257            handleException(e);
258        }
259    }
260
261    @Override
262    public void setBlob(final int parameterIndex, final InputStream inputStream) throws SQLException {
263        checkOpen();
264        try {
265            getDelegatePreparedStatement().setBlob(parameterIndex, inputStream);
266        } catch (final SQLException e) {
267            handleException(e);
268        }
269    }
270
271    @Override
272    public void setBlob(final int parameterIndex, final InputStream inputStream, final long length)
273            throws SQLException {
274        checkOpen();
275        try {
276            getDelegatePreparedStatement().setBlob(parameterIndex, inputStream, length);
277        } catch (final SQLException e) {
278            handleException(e);
279        }
280    }
281
282    @Override
283    public void setBoolean(final int parameterIndex, final boolean x) throws SQLException {
284        checkOpen();
285        try {
286            getDelegatePreparedStatement().setBoolean(parameterIndex, x);
287        } catch (final SQLException e) {
288            handleException(e);
289        }
290    }
291
292    @Override
293    public void setByte(final int parameterIndex, final byte x) throws SQLException {
294        checkOpen();
295        try {
296            getDelegatePreparedStatement().setByte(parameterIndex, x);
297        } catch (final SQLException e) {
298            handleException(e);
299        }
300    }
301
302    @Override
303    public void setBytes(final int parameterIndex, final byte[] x) throws SQLException {
304        checkOpen();
305        try {
306            getDelegatePreparedStatement().setBytes(parameterIndex, x);
307        } catch (final SQLException e) {
308            handleException(e);
309        }
310    }
311
312    @Override
313    public void setCharacterStream(final int parameterIndex, final Reader reader) throws SQLException {
314        checkOpen();
315        try {
316            getDelegatePreparedStatement().setCharacterStream(parameterIndex, reader);
317        } catch (final SQLException e) {
318            handleException(e);
319        }
320    }
321
322    @Override
323    public void setCharacterStream(final int parameterIndex, final Reader reader, final int length)
324            throws SQLException {
325        checkOpen();
326        try {
327            getDelegatePreparedStatement().setCharacterStream(parameterIndex, reader, length);
328        } catch (final SQLException e) {
329            handleException(e);
330        }
331    }
332
333    @Override
334    public void setCharacterStream(final int parameterIndex, final Reader reader, final long length)
335            throws SQLException {
336        checkOpen();
337        try {
338            getDelegatePreparedStatement().setCharacterStream(parameterIndex, reader, length);
339        } catch (final SQLException e) {
340            handleException(e);
341        }
342    }
343
344    @Override
345    public void setClob(final int i, final Clob x) throws SQLException {
346        checkOpen();
347        try {
348            getDelegatePreparedStatement().setClob(i, x);
349        } catch (final SQLException e) {
350            handleException(e);
351        }
352    }
353
354    @Override
355    public void setClob(final int parameterIndex, final Reader reader) throws SQLException {
356        checkOpen();
357        try {
358            getDelegatePreparedStatement().setClob(parameterIndex, reader);
359        } catch (final SQLException e) {
360            handleException(e);
361        }
362    }
363
364    @Override
365    public void setClob(final int parameterIndex, final Reader reader, final long length) throws SQLException {
366        checkOpen();
367        try {
368            getDelegatePreparedStatement().setClob(parameterIndex, reader, length);
369        } catch (final SQLException e) {
370            handleException(e);
371        }
372    }
373
374    @Override
375    public void setDate(final int parameterIndex, final Date x) throws SQLException {
376        checkOpen();
377        try {
378            getDelegatePreparedStatement().setDate(parameterIndex, x);
379        } catch (final SQLException e) {
380            handleException(e);
381        }
382    }
383
384    @Override
385    public void setDate(final int parameterIndex, final Date x, final Calendar cal) throws SQLException {
386        checkOpen();
387        try {
388            getDelegatePreparedStatement().setDate(parameterIndex, x, cal);
389        } catch (final SQLException e) {
390            handleException(e);
391        }
392    }
393
394    @Override
395    public void setDouble(final int parameterIndex, final double x) throws SQLException {
396        checkOpen();
397        try {
398            getDelegatePreparedStatement().setDouble(parameterIndex, x);
399        } catch (final SQLException e) {
400            handleException(e);
401        }
402    }
403
404    @Override
405    public void setFloat(final int parameterIndex, final float x) throws SQLException {
406        checkOpen();
407        try {
408            getDelegatePreparedStatement().setFloat(parameterIndex, x);
409        } catch (final SQLException e) {
410            handleException(e);
411        }
412    }
413
414    @Override
415    public void setInt(final int parameterIndex, final int x) throws SQLException {
416        checkOpen();
417        try {
418            getDelegatePreparedStatement().setInt(parameterIndex, x);
419        } catch (final SQLException e) {
420            handleException(e);
421        }
422    }
423
424    @Override
425    public void setLong(final int parameterIndex, final long x) throws SQLException {
426        checkOpen();
427        try {
428            getDelegatePreparedStatement().setLong(parameterIndex, x);
429        } catch (final SQLException e) {
430            handleException(e);
431        }
432    }
433
434    @Override
435    public void setNCharacterStream(final int parameterIndex, final Reader reader) throws SQLException {
436        checkOpen();
437        try {
438            getDelegatePreparedStatement().setNCharacterStream(parameterIndex, reader);
439        } catch (final SQLException e) {
440            handleException(e);
441        }
442    }
443
444    @Override
445    public void setNCharacterStream(final int parameterIndex, final Reader value, final long length)
446            throws SQLException {
447        checkOpen();
448        try {
449            getDelegatePreparedStatement().setNCharacterStream(parameterIndex, value, length);
450        } catch (final SQLException e) {
451            handleException(e);
452        }
453    }
454
455    @Override
456    public void setNClob(final int parameterIndex, final NClob value) throws SQLException {
457        checkOpen();
458        try {
459            getDelegatePreparedStatement().setNClob(parameterIndex, value);
460        } catch (final SQLException e) {
461            handleException(e);
462        }
463    }
464
465    @Override
466    public void setNClob(final int parameterIndex, final Reader reader) throws SQLException {
467        checkOpen();
468        try {
469            getDelegatePreparedStatement().setNClob(parameterIndex, reader);
470        } catch (final SQLException e) {
471            handleException(e);
472        }
473    }
474
475    @Override
476    public void setNClob(final int parameterIndex, final Reader reader, final long length) throws SQLException {
477        checkOpen();
478        try {
479            getDelegatePreparedStatement().setNClob(parameterIndex, reader, length);
480        } catch (final SQLException e) {
481            handleException(e);
482        }
483    }
484
485    @Override
486    public void setNString(final int parameterIndex, final String value) throws SQLException {
487        checkOpen();
488        try {
489            getDelegatePreparedStatement().setNString(parameterIndex, value);
490        } catch (final SQLException e) {
491            handleException(e);
492        }
493    }
494
495    @Override
496    public void setNull(final int parameterIndex, final int sqlType) throws SQLException {
497        checkOpen();
498        try {
499            getDelegatePreparedStatement().setNull(parameterIndex, sqlType);
500        } catch (final SQLException e) {
501            handleException(e);
502        }
503    }
504
505    @Override
506    public void setNull(final int paramIndex, final int sqlType, final String typeName) throws SQLException {
507        checkOpen();
508        try {
509            getDelegatePreparedStatement().setNull(paramIndex, sqlType, typeName);
510        } catch (final SQLException e) {
511            handleException(e);
512        }
513    }
514
515    @Override
516    public void setObject(final int parameterIndex, final Object x) throws SQLException {
517        checkOpen();
518        try {
519            getDelegatePreparedStatement().setObject(parameterIndex, x);
520        } catch (final SQLException e) {
521            handleException(e);
522        }
523    }
524
525    @Override
526    public void setObject(final int parameterIndex, final Object x, final int targetSqlType) throws SQLException {
527        checkOpen();
528        try {
529            getDelegatePreparedStatement().setObject(parameterIndex, x, targetSqlType);
530        } catch (final SQLException e) {
531            handleException(e);
532        }
533    }
534
535    @Override
536    public void setObject(final int parameterIndex, final Object x, final int targetSqlType, final int scale)
537            throws SQLException {
538        checkOpen();
539        try {
540            getDelegatePreparedStatement().setObject(parameterIndex, x, targetSqlType, scale);
541        } catch (final SQLException e) {
542            handleException(e);
543        }
544    }
545
546    /**
547     * @since 2.5.0
548     */
549    @Override
550    public void setObject(final int parameterIndex, final Object x, final SQLType targetSqlType) throws SQLException {
551        checkOpen();
552        try {
553            getDelegatePreparedStatement().setObject(parameterIndex, x, targetSqlType);
554        } catch (final SQLException e) {
555            handleException(e);
556        }
557    }
558
559    /**
560     * @since 2.5.0
561     */
562    @Override
563    public void setObject(final int parameterIndex, final Object x, final SQLType targetSqlType, final int scaleOrLength) throws SQLException {
564        checkOpen();
565        try {
566            getDelegatePreparedStatement().setObject(parameterIndex, x, targetSqlType, scaleOrLength);
567        } catch (final SQLException e) {
568            handleException(e);
569        }
570    }
571
572    @Override
573    public void setRef(final int i, final Ref x) throws SQLException {
574        checkOpen();
575        try {
576            getDelegatePreparedStatement().setRef(i, x);
577        } catch (final SQLException e) {
578            handleException(e);
579        }
580    }
581
582    @Override
583    public void setRowId(final int parameterIndex, final RowId value) throws SQLException {
584        checkOpen();
585        try {
586            getDelegatePreparedStatement().setRowId(parameterIndex, value);
587        } catch (final SQLException e) {
588            handleException(e);
589        }
590    }
591
592    @Override
593    public void setShort(final int parameterIndex, final short x) throws SQLException {
594        checkOpen();
595        try {
596            getDelegatePreparedStatement().setShort(parameterIndex, x);
597        } catch (final SQLException e) {
598            handleException(e);
599        }
600    }
601
602    @Override
603    public void setSQLXML(final int parameterIndex, final SQLXML value) throws SQLException {
604        checkOpen();
605        try {
606            getDelegatePreparedStatement().setSQLXML(parameterIndex, value);
607        } catch (final SQLException e) {
608            handleException(e);
609        }
610    }
611
612    @Override
613    public void setString(final int parameterIndex, final String x) throws SQLException {
614        checkOpen();
615        try {
616            getDelegatePreparedStatement().setString(parameterIndex, x);
617        } catch (final SQLException e) {
618            handleException(e);
619        }
620    }
621
622    @Override
623    public void setTime(final int parameterIndex, final Time x) throws SQLException {
624        checkOpen();
625        try {
626            getDelegatePreparedStatement().setTime(parameterIndex, x);
627        } catch (final SQLException e) {
628            handleException(e);
629        }
630    }
631
632    @Override
633    public void setTime(final int parameterIndex, final Time x, final Calendar cal) throws SQLException {
634        checkOpen();
635        try {
636            getDelegatePreparedStatement().setTime(parameterIndex, x, cal);
637        } catch (final SQLException e) {
638            handleException(e);
639        }
640    }
641
642    @Override
643    public void setTimestamp(final int parameterIndex, final Timestamp x) throws SQLException {
644        checkOpen();
645        try {
646            getDelegatePreparedStatement().setTimestamp(parameterIndex, x);
647        } catch (final SQLException e) {
648            handleException(e);
649        }
650    }
651
652    @Override
653    public void setTimestamp(final int parameterIndex, final Timestamp x, final Calendar cal) throws SQLException {
654        checkOpen();
655        try {
656            getDelegatePreparedStatement().setTimestamp(parameterIndex, x, cal);
657        } catch (final SQLException e) {
658            handleException(e);
659        }
660    }
661
662    /** @deprecated Use setAsciiStream(), setCharacterStream() or setNCharacterStream() */
663    @Deprecated
664    @Override
665    public void setUnicodeStream(final int parameterIndex, final InputStream x, final int length) throws SQLException {
666        checkOpen();
667        try {
668            getDelegatePreparedStatement().setUnicodeStream(parameterIndex, x, length);
669        } catch (final SQLException e) {
670            handleException(e);
671        }
672    }
673
674    @Override
675    public void setURL(final int parameterIndex, final java.net.URL x) throws SQLException {
676        checkOpen();
677        try {
678            getDelegatePreparedStatement().setURL(parameterIndex, x);
679        } catch (final SQLException e) {
680            handleException(e);
681        }
682    }
683
684    /**
685     * Returns a String representation of this object.
686     *
687     * @return String
688     */
689    @SuppressWarnings("resource")
690    @Override
691    public synchronized String toString() {
692        final Statement statement = getDelegate();
693        return statement == null ? "NULL" : statement.toString();
694    }
695}