DelegatingCallableStatement.java

  1. /*
  2.  * Licensed to the Apache Software Foundation (ASF) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * The ASF licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *      http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.apache.commons.dbcp2;

  19. import java.io.InputStream;
  20. import java.io.Reader;
  21. import java.math.BigDecimal;
  22. import java.net.URL;
  23. import java.sql.Array;
  24. import java.sql.Blob;
  25. import java.sql.CallableStatement;
  26. import java.sql.Clob;
  27. import java.sql.Date;
  28. import java.sql.NClob;
  29. import java.sql.Ref;
  30. import java.sql.RowId;
  31. import java.sql.SQLException;
  32. import java.sql.SQLType;
  33. import java.sql.SQLXML;
  34. import java.sql.Time;
  35. import java.sql.Timestamp;
  36. import java.util.Calendar;
  37. import java.util.Map;

  39. /**
  40.  * A base delegating implementation of {@link CallableStatement}.
  41.  * <p>
  42.  * All of the methods from the {@link CallableStatement} interface simply call the corresponding method on the
  43.  * "delegate" provided in my constructor.
  44.  * </p>
  45.  * <p>
  46.  * Extends AbandonedTrace to implement Statement tracking and logging of code which created the Statement. Tracking the
  47.  * Statement ensures that the Connection which created it can close any open Statement's on Connection close.
  48.  * </p>
  49.  *
  50.  * @since 2.0
  51.  */
  52. public class DelegatingCallableStatement extends DelegatingPreparedStatement implements CallableStatement {

  54.     /**
  55.      * Creates a wrapper for the Statement which traces this Statement to the Connection which created it and the code
  56.      * which created it.
  57.      *
  58.      * @param connection
  59.      *            the {@link DelegatingConnection} that created this statement
  60.      * @param statement
  61.      *            the {@link CallableStatement} to delegate all calls to
  62.      */
  63.     public DelegatingCallableStatement(final DelegatingConnection<?> connection, final CallableStatement statement) {
  64.         super(connection, statement);
  65.     }

  67.     @Override
  68.     public Array getArray(final int parameterIndex) throws SQLException {
  69.         checkOpen();
  70.         try {
  71.             return getDelegateCallableStatement().getArray(parameterIndex);
  72.         } catch (final SQLException e) {
  73.             handleException(e);
  74.             return null;
  75.         }
  76.     }

  78.     @Override
  79.     public Array getArray(final String parameterName) throws SQLException {
  80.         checkOpen();
  81.         try {
  82.             return getDelegateCallableStatement().getArray(parameterName);
  83.         } catch (final SQLException e) {
  84.             handleException(e);
  85.             return null;
  86.         }
  87.     }

  89.     @Override
  90.     public BigDecimal getBigDecimal(final int parameterIndex) throws SQLException {
  91.         checkOpen();
  92.         try {
  93.             return getDelegateCallableStatement().getBigDecimal(parameterIndex);
  94.         } catch (final SQLException e) {
  95.             handleException(e);
  96.             return null;
  97.         }
  98.     }

  100.     /** @deprecated Use {@link #getBigDecimal(int)} or {@link #getBigDecimal(String)} */
  101.     @Override
  102.     @Deprecated
  103.     public BigDecimal getBigDecimal(final int parameterIndex, final int scale) throws SQLException {
  104.         checkOpen();
  105.         try {
  106.             return getDelegateCallableStatement().getBigDecimal(parameterIndex, scale);
  107.         } catch (final SQLException e) {
  108.             handleException(e);
  109.             return null;
  110.         }
  111.     }

  113.     @Override
  114.     public BigDecimal getBigDecimal(final String parameterName) throws SQLException {
  115.         checkOpen();
  116.         try {
  117.             return getDelegateCallableStatement().getBigDecimal(parameterName);
  118.         } catch (final SQLException e) {
  119.             handleException(e);
  120.             return null;
  121.         }
  122.     }

  124.     @Override
  125.     public Blob getBlob(final int parameterIndex) throws SQLException {
  126.         checkOpen();
  127.         try {
  128.             return getDelegateCallableStatement().getBlob(parameterIndex);
  129.         } catch (final SQLException e) {
  130.             handleException(e);
  131.             return null;
  132.         }
  133.     }

  135.     @Override
  136.     public Blob getBlob(final String parameterName) throws SQLException {
  137.         checkOpen();
  138.         try {
  139.             return getDelegateCallableStatement().getBlob(parameterName);
  140.         } catch (final SQLException e) {
  141.             handleException(e);
  142.             return null;
  143.         }
  144.     }

  146.     @Override
  147.     public boolean getBoolean(final int parameterIndex) throws SQLException {
  148.         checkOpen();
  149.         try {
  150.             return getDelegateCallableStatement().getBoolean(parameterIndex);
  151.         } catch (final SQLException e) {
  152.             handleException(e);
  153.             return false;
  154.         }
  155.     }

  157.     @Override
  158.     public boolean getBoolean(final String parameterName) throws SQLException {
  159.         checkOpen();
  160.         try {
  161.             return getDelegateCallableStatement().getBoolean(parameterName);
  162.         } catch (final SQLException e) {
  163.             handleException(e);
  164.             return false;
  165.         }
  166.     }

  168.     @Override
  169.     public byte getByte(final int parameterIndex) throws SQLException {
  170.         checkOpen();
  171.         try {
  172.             return getDelegateCallableStatement().getByte(parameterIndex);
  173.         } catch (final SQLException e) {
  174.             handleException(e);
  175.             return 0;
  176.         }
  177.     }

  179.     @Override
  180.     public byte getByte(final String parameterName) throws SQLException {
  181.         checkOpen();
  182.         try {
  183.             return getDelegateCallableStatement().getByte(parameterName);
  184.         } catch (final SQLException e) {
  185.             handleException(e);
  186.             return 0;
  187.         }
  188.     }

  190.     @Override
  191.     public byte[] getBytes(final int parameterIndex) throws SQLException {
  192.         checkOpen();
  193.         try {
  194.             return getDelegateCallableStatement().getBytes(parameterIndex);
  195.         } catch (final SQLException e) {
  196.             handleException(e);
  197.             return null;
  198.         }
  199.     }

  201.     @Override
  202.     public byte[] getBytes(final String parameterName) throws SQLException {
  203.         checkOpen();
  204.         try {
  205.             return getDelegateCallableStatement().getBytes(parameterName);
  206.         } catch (final SQLException e) {
  207.             handleException(e);
  208.             return null;
  209.         }
  210.     }

  212.     @Override
  213.     public Reader getCharacterStream(final int parameterIndex) throws SQLException {
  214.         checkOpen();
  215.         try {
  216.             return getDelegateCallableStatement().getCharacterStream(parameterIndex);
  217.         } catch (final SQLException e) {
  218.             handleException(e);
  219.             return null;
  220.         }
  221.     }

  223.     @Override
  224.     public Reader getCharacterStream(final String parameterName) throws SQLException {
  225.         checkOpen();
  226.         try {
  227.             return getDelegateCallableStatement().getCharacterStream(parameterName);
  228.         } catch (final SQLException e) {
  229.             handleException(e);
  230.             return null;
  231.         }
  232.     }

  234.     @Override
  235.     public Clob getClob(final int parameterIndex) throws SQLException {
  236.         checkOpen();
  237.         try {
  238.             return getDelegateCallableStatement().getClob(parameterIndex);
  239.         } catch (final SQLException e) {
  240.             handleException(e);
  241.             return null;
  242.         }
  243.     }

  245.     @Override
  246.     public Clob getClob(final String parameterName) throws SQLException {
  247.         checkOpen();
  248.         try {
  249.             return getDelegateCallableStatement().getClob(parameterName);
  250.         } catch (final SQLException e) {
  251.             handleException(e);
  252.             return null;
  253.         }
  254.     }

  256.     @Override
  257.     public Date getDate(final int parameterIndex) throws SQLException {
  258.         checkOpen();
  259.         try {
  260.             return getDelegateCallableStatement().getDate(parameterIndex);
  261.         } catch (final SQLException e) {
  262.             handleException(e);
  263.             return null;
  264.         }
  265.     }

  267.     @Override
  268.     public Date getDate(final int parameterIndex, final Calendar cal) throws SQLException {
  269.         checkOpen();
  270.         try {
  271.             return getDelegateCallableStatement().getDate(parameterIndex, cal);
  272.         } catch (final SQLException e) {
  273.             handleException(e);
  274.             return null;
  275.         }
  276.     }

  278.     @Override
  279.     public Date getDate(final String parameterName) throws SQLException {
  280.         checkOpen();
  281.         try {
  282.             return getDelegateCallableStatement().getDate(parameterName);
  283.         } catch (final SQLException e) {
  284.             handleException(e);
  285.             return null;
  286.         }
  287.     }

  289.     @Override
  290.     public Date getDate(final String parameterName, final Calendar cal) throws SQLException {
  291.         checkOpen();
  292.         try {
  293.             return getDelegateCallableStatement().getDate(parameterName, cal);
  294.         } catch (final SQLException e) {
  295.             handleException(e);
  296.             return null;
  297.         }
  298.     }

  300.     private CallableStatement getDelegateCallableStatement() {
  301.         return (CallableStatement) getDelegate();
  302.     }

  304.     @Override
  305.     public double getDouble(final int parameterIndex) throws SQLException {
  306.         checkOpen();
  307.         try {
  308.             return getDelegateCallableStatement().getDouble(parameterIndex);
  309.         } catch (final SQLException e) {
  310.             handleException(e);
  311.             return 0;
  312.         }
  313.     }

  315.     @Override
  316.     public double getDouble(final String parameterName) throws SQLException {
  317.         checkOpen();
  318.         try {
  319.             return getDelegateCallableStatement().getDouble(parameterName);
  320.         } catch (final SQLException e) {
  321.             handleException(e);
  322.             return 0;
  323.         }
  324.     }

  326.     @Override
  327.     public float getFloat(final int parameterIndex) throws SQLException {
  328.         checkOpen();
  329.         try {
  330.             return getDelegateCallableStatement().getFloat(parameterIndex);
  331.         } catch (final SQLException e) {
  332.             handleException(e);
  333.             return 0;
  334.         }
  335.     }

  337.     @Override
  338.     public float getFloat(final String parameterName) throws SQLException {
  339.         checkOpen();
  340.         try {
  341.             return getDelegateCallableStatement().getFloat(parameterName);
  342.         } catch (final SQLException e) {
  343.             handleException(e);
  344.             return 0;
  345.         }
  346.     }

  348.     @Override
  349.     public int getInt(final int parameterIndex) throws SQLException {
  350.         checkOpen();
  351.         try {
  352.             return getDelegateCallableStatement().getInt(parameterIndex);
  353.         } catch (final SQLException e) {
  354.             handleException(e);
  355.             return 0;
  356.         }
  357.     }

  359.     @Override
  360.     public int getInt(final String parameterName) throws SQLException {
  361.         checkOpen();
  362.         try {
  363.             return getDelegateCallableStatement().getInt(parameterName);
  364.         } catch (final SQLException e) {
  365.             handleException(e);
  366.             return 0;
  367.         }
  368.     }

  370.     @Override
  371.     public long getLong(final int parameterIndex) throws SQLException {
  372.         checkOpen();
  373.         try {
  374.             return getDelegateCallableStatement().getLong(parameterIndex);
  375.         } catch (final SQLException e) {
  376.             handleException(e);
  377.             return 0;
  378.         }
  379.     }

  381.     @Override
  382.     public long getLong(final String parameterName) throws SQLException {
  383.         checkOpen();
  384.         try {
  385.             return getDelegateCallableStatement().getLong(parameterName);
  386.         } catch (final SQLException e) {
  387.             handleException(e);
  388.             return 0;
  389.         }
  390.     }

  392.     @Override
  393.     public Reader getNCharacterStream(final int parameterIndex) throws SQLException {
  394.         checkOpen();
  395.         try {
  396.             return getDelegateCallableStatement().getNCharacterStream(parameterIndex);
  397.         } catch (final SQLException e) {
  398.             handleException(e);
  399.             return null;
  400.         }
  401.     }

  403.     @Override
  404.     public Reader getNCharacterStream(final String parameterName) throws SQLException {
  405.         checkOpen();
  406.         try {
  407.             return getDelegateCallableStatement().getNCharacterStream(parameterName);
  408.         } catch (final SQLException e) {
  409.             handleException(e);
  410.             return null;
  411.         }
  412.     }

  414.     @Override
  415.     public NClob getNClob(final int parameterIndex) throws SQLException {
  416.         checkOpen();
  417.         try {
  418.             return getDelegateCallableStatement().getNClob(parameterIndex);
  419.         } catch (final SQLException e) {
  420.             handleException(e);
  421.             return null;
  422.         }
  423.     }

  425.     @Override
  426.     public NClob getNClob(final String parameterName) throws SQLException {
  427.         checkOpen();
  428.         try {
  429.             return getDelegateCallableStatement().getNClob(parameterName);
  430.         } catch (final SQLException e) {
  431.             handleException(e);
  432.             return null;
  433.         }
  434.     }

  436.     @Override
  437.     public String getNString(final int parameterIndex) throws SQLException {
  438.         checkOpen();
  439.         try {
  440.             return getDelegateCallableStatement().getNString(parameterIndex);
  441.         } catch (final SQLException e) {
  442.             handleException(e);
  443.             return null;
  444.         }
  445.     }

  447.     @Override
  448.     public String getNString(final String parameterName) throws SQLException {
  449.         checkOpen();
  450.         try {
  451.             return getDelegateCallableStatement().getNString(parameterName);
  452.         } catch (final SQLException e) {
  453.             handleException(e);
  454.             return null;
  455.         }
  456.     }

  458.     @Override
  459.     public Object getObject(final int parameterIndex) throws SQLException {
  460.         checkOpen();
  461.         try {
  462.             return getDelegateCallableStatement().getObject(parameterIndex);
  463.         } catch (final SQLException e) {
  464.             handleException(e);
  465.             return null;
  466.         }
  467.     }

  469.     @Override
  470.     public <T> T getObject(final int parameterIndex, final Class<T> type) throws SQLException {
  471.         checkOpen();
  472.         try {
  473.             return getDelegateCallableStatement().getObject(parameterIndex, type);
  474.         } catch (final SQLException e) {
  475.             handleException(e);
  476.             return null;
  477.         }
  478.     }

  480.     @Override
  481.     public Object getObject(final int i, final Map<String, Class<?>> map) throws SQLException {
  482.         checkOpen();
  483.         try {
  484.             return getDelegateCallableStatement().getObject(i, map);
  485.         } catch (final SQLException e) {
  486.             handleException(e);
  487.             return null;
  488.         }
  489.     }

  491.     @Override
  492.     public Object getObject(final String parameterName) throws SQLException {
  493.         checkOpen();
  494.         try {
  495.             return getDelegateCallableStatement().getObject(parameterName);
  496.         } catch (final SQLException e) {
  497.             handleException(e);
  498.             return null;
  499.         }
  500.     }

  502.     @Override
  503.     public <T> T getObject(final String parameterName, final Class<T> type) throws SQLException {
  504.         checkOpen();
  505.         try {
  506.             return getDelegateCallableStatement().getObject(parameterName, type);
  507.         } catch (final SQLException e) {
  508.             handleException(e);
  509.             return null;
  510.         }
  511.     }

  513.     @Override
  514.     public Object getObject(final String parameterName, final Map<String, Class<?>> map) throws SQLException {
  515.         checkOpen();
  516.         try {
  517.             return getDelegateCallableStatement().getObject(parameterName, map);
  518.         } catch (final SQLException e) {
  519.             handleException(e);
  520.             return null;
  521.         }
  522.     }

  524.     @Override
  525.     public Ref getRef(final int parameterIndex) throws SQLException {
  526.         checkOpen();
  527.         try {
  528.             return getDelegateCallableStatement().getRef(parameterIndex);
  529.         } catch (final SQLException e) {
  530.             handleException(e);
  531.             return null;
  532.         }
  533.     }

  535.     @Override
  536.     public Ref getRef(final String parameterName) throws SQLException {
  537.         checkOpen();
  538.         try {
  539.             return getDelegateCallableStatement().getRef(parameterName);
  540.         } catch (final SQLException e) {
  541.             handleException(e);
  542.             return null;
  543.         }
  544.     }

  546.     @Override
  547.     public RowId getRowId(final int parameterIndex) throws SQLException {
  548.         checkOpen();
  549.         try {
  550.             return getDelegateCallableStatement().getRowId(parameterIndex);
  551.         } catch (final SQLException e) {
  552.             handleException(e);
  553.             return null;
  554.         }
  555.     }

  557.     @Override
  558.     public RowId getRowId(final String parameterName) throws SQLException {
  559.         checkOpen();
  560.         try {
  561.             return getDelegateCallableStatement().getRowId(parameterName);
  562.         } catch (final SQLException e) {
  563.             handleException(e);
  564.             return null;
  565.         }
  566.     }

  568.     @Override
  569.     public short getShort(final int parameterIndex) throws SQLException {
  570.         checkOpen();
  571.         try {
  572.             return getDelegateCallableStatement().getShort(parameterIndex);
  573.         } catch (final SQLException e) {
  574.             handleException(e);
  575.             return 0;
  576.         }
  577.     }

  579.     @Override
  580.     public short getShort(final String parameterName) throws SQLException {
  581.         checkOpen();
  582.         try {
  583.             return getDelegateCallableStatement().getShort(parameterName);
  584.         } catch (final SQLException e) {
  585.             handleException(e);
  586.             return 0;
  587.         }
  588.     }

  590.     @Override
  591.     public SQLXML getSQLXML(final int parameterIndex) throws SQLException {
  592.         checkOpen();
  593.         try {
  594.             return getDelegateCallableStatement().getSQLXML(parameterIndex);
  595.         } catch (final SQLException e) {
  596.             handleException(e);
  597.             return null;
  598.         }
  599.     }

  601.     @Override
  602.     public SQLXML getSQLXML(final String parameterName) throws SQLException {
  603.         checkOpen();
  604.         try {
  605.             return getDelegateCallableStatement().getSQLXML(parameterName);
  606.         } catch (final SQLException e) {
  607.             handleException(e);
  608.             return null;
  609.         }
  610.     }

  612.     @Override
  613.     public String getString(final int parameterIndex) throws SQLException {
  614.         checkOpen();
  615.         try {
  616.             return getDelegateCallableStatement().getString(parameterIndex);
  617.         } catch (final SQLException e) {
  618.             handleException(e);
  619.             return null;
  620.         }
  621.     }

  623.     @Override
  624.     public String getString(final String parameterName) throws SQLException {
  625.         checkOpen();
  626.         try {
  627.             return getDelegateCallableStatement().getString(parameterName);
  628.         } catch (final SQLException e) {
  629.             handleException(e);
  630.             return null;
  631.         }
  632.     }

  634.     @Override
  635.     public Time getTime(final int parameterIndex) throws SQLException {
  636.         checkOpen();
  637.         try {
  638.             return getDelegateCallableStatement().getTime(parameterIndex);
  639.         } catch (final SQLException e) {
  640.             handleException(e);
  641.             return null;
  642.         }
  643.     }

  645.     @Override
  646.     public Time getTime(final int parameterIndex, final Calendar cal) throws SQLException {
  647.         checkOpen();
  648.         try {
  649.             return getDelegateCallableStatement().getTime(parameterIndex, cal);
  650.         } catch (final SQLException e) {
  651.             handleException(e);
  652.             return null;
  653.         }
  654.     }

  656.     @Override
  657.     public Time getTime(final String parameterName) throws SQLException {
  658.         checkOpen();
  659.         try {
  660.             return getDelegateCallableStatement().getTime(parameterName);
  661.         } catch (final SQLException e) {
  662.             handleException(e);
  663.             return null;
  664.         }
  665.     }

  667.     @Override
  668.     public Time getTime(final String parameterName, final Calendar cal) throws SQLException {
  669.         checkOpen();
  670.         try {
  671.             return getDelegateCallableStatement().getTime(parameterName, cal);
  672.         } catch (final SQLException e) {
  673.             handleException(e);
  674.             return null;
  675.         }
  676.     }

  678.     @Override
  679.     public Timestamp getTimestamp(final int parameterIndex) throws SQLException {
  680.         checkOpen();
  681.         try {
  682.             return getDelegateCallableStatement().getTimestamp(parameterIndex);
  683.         } catch (final SQLException e) {
  684.             handleException(e);
  685.             return null;
  686.         }
  687.     }

  689.     @Override
  690.     public Timestamp getTimestamp(final int parameterIndex, final Calendar cal) throws SQLException {
  691.         checkOpen();
  692.         try {
  693.             return getDelegateCallableStatement().getTimestamp(parameterIndex, cal);
  694.         } catch (final SQLException e) {
  695.             handleException(e);
  696.             return null;
  697.         }
  698.     }

  700.     @Override
  701.     public Timestamp getTimestamp(final String parameterName) throws SQLException {
  702.         checkOpen();
  703.         try {
  704.             return getDelegateCallableStatement().getTimestamp(parameterName);
  705.         } catch (final SQLException e) {
  706.             handleException(e);
  707.             return null;
  708.         }
  709.     }

  711.     @Override
  712.     public Timestamp getTimestamp(final String parameterName, final Calendar cal) throws SQLException {
  713.         checkOpen();
  714.         try {
  715.             return getDelegateCallableStatement().getTimestamp(parameterName, cal);
  716.         } catch (final SQLException e) {
  717.             handleException(e);
  718.             return null;
  719.         }
  720.     }

  722.     @Override
  723.     public URL getURL(final int parameterIndex) throws SQLException {
  724.         checkOpen();
  725.         try {
  726.             return getDelegateCallableStatement().getURL(parameterIndex);
  727.         } catch (final SQLException e) {
  728.             handleException(e);
  729.             return null;
  730.         }
  731.     }

  733.     @Override
  734.     public URL getURL(final String parameterName) throws SQLException {
  735.         checkOpen();
  736.         try {
  737.             return getDelegateCallableStatement().getURL(parameterName);
  738.         } catch (final SQLException e) {
  739.             handleException(e);
  740.             return null;
  741.         }
  742.     }

  744.     @Override
  745.     public void registerOutParameter(final int parameterIndex, final int sqlType) throws SQLException {
  746.         checkOpen();
  747.         try {
  748.             getDelegateCallableStatement().registerOutParameter(parameterIndex, sqlType);
  749.         } catch (final SQLException e) {
  750.             handleException(e);
  751.         }
  752.     }

  754.     @Override
  755.     public void registerOutParameter(final int parameterIndex, final int sqlType, final int scale) throws SQLException {
  756.         checkOpen();
  757.         try {
  758.             getDelegateCallableStatement().registerOutParameter(parameterIndex, sqlType, scale);
  759.         } catch (final SQLException e) {
  760.             handleException(e);
  761.         }
  762.     }

  764.     @Override
  765.     public void registerOutParameter(final int paramIndex, final int sqlType, final String typeName)
  766.             throws SQLException {
  767.         checkOpen();
  768.         try {
  769.             getDelegateCallableStatement().registerOutParameter(paramIndex, sqlType, typeName);
  770.         } catch (final SQLException e) {
  771.             handleException(e);
  772.         }
  773.     }

  775.     /**
  776.      * @since 2.5.0
  777.      */
  778.     @Override
  779.     public void registerOutParameter(final int parameterIndex, final SQLType sqlType) throws SQLException {
  780.         checkOpen();
  781.         try {
  782.             getDelegateCallableStatement().registerOutParameter(parameterIndex, sqlType);
  783.         } catch (final SQLException e) {
  784.             handleException(e);
  785.         }
  786.     }

  788.     /**
  789.      * @since 2.5.0
  790.      */
  791.     @Override
  792.     public void registerOutParameter(final int parameterIndex, final SQLType sqlType, final int scale)
  793.             throws SQLException {
  794.         checkOpen();
  795.         try {
  796.             getDelegateCallableStatement().registerOutParameter(parameterIndex, sqlType, scale);
  797.         } catch (final SQLException e) {
  798.             handleException(e);
  799.         }
  800.     }

  802.     /**
  803.      * @since 2.5.0
  804.      */
  805.     @Override
  806.     public void registerOutParameter(final int parameterIndex, final SQLType sqlType, final String typeName)
  807.             throws SQLException {
  808.         checkOpen();
  809.         try {
  810.             getDelegateCallableStatement().registerOutParameter(parameterIndex, sqlType, typeName);
  811.         } catch (final SQLException e) {
  812.             handleException(e);
  813.         }
  814.     }

  816.     @Override
  817.     public void registerOutParameter(final String parameterName, final int sqlType) throws SQLException {
  818.         checkOpen();
  819.         try {
  820.             getDelegateCallableStatement().registerOutParameter(parameterName, sqlType);
  821.         } catch (final SQLException e) {
  822.             handleException(e);
  823.         }
  824.     }

  826.     @Override
  827.     public void registerOutParameter(final String parameterName, final int sqlType, final int scale)
  828.             throws SQLException {
  829.         checkOpen();
  830.         try {
  831.             getDelegateCallableStatement().registerOutParameter(parameterName, sqlType, scale);
  832.         } catch (final SQLException e) {
  833.             handleException(e);
  834.         }
  835.     }

  837.     @Override
  838.     public void registerOutParameter(final String parameterName, final int sqlType, final String typeName)
  839.             throws SQLException {
  840.         checkOpen();
  841.         try {
  842.             getDelegateCallableStatement().registerOutParameter(parameterName, sqlType, typeName);
  843.         } catch (final SQLException e) {
  844.             handleException(e);
  845.         }
  846.     }

  848.     /**
  849.      * @since 2.5.0
  850.      */
  851.     @Override
  852.     public void registerOutParameter(final String parameterName, final SQLType sqlType) throws SQLException {
  853.         checkOpen();
  854.         try {
  855.             getDelegateCallableStatement().registerOutParameter(parameterName, sqlType);
  856.         } catch (final SQLException e) {
  857.             handleException(e);
  858.         }
  859.     }

  861.     /**
  862.      * @since 2.5.0
  863.      */
  864.     @Override
  865.     public void registerOutParameter(final String parameterName, final SQLType sqlType, final int scale)
  866.             throws SQLException {
  867.         checkOpen();
  868.         try {
  869.             getDelegateCallableStatement().registerOutParameter(parameterName, sqlType, scale);
  870.         } catch (final SQLException e) {
  871.             handleException(e);
  872.         }
  873.     }

  875.     /**
  876.      * @since 2.5.0
  877.      */
  878.     @Override
  879.     public void registerOutParameter(final String parameterName, final SQLType sqlType, final String typeName)
  880.             throws SQLException {
  881.         checkOpen();
  882.         try {
  883.             getDelegateCallableStatement().registerOutParameter(parameterName, sqlType, typeName);
  884.         } catch (final SQLException e) {
  885.             handleException(e);
  886.         }
  887.     }

  889.     @Override
  890.     public void setAsciiStream(final String parameterName, final InputStream inputStream) throws SQLException {
  891.         checkOpen();
  892.         try {
  893.             getDelegateCallableStatement().setAsciiStream(parameterName, inputStream);
  894.         } catch (final SQLException e) {
  895.             handleException(e);
  896.         }
  897.     }

  899.     @Override
  900.     public void setAsciiStream(final String parameterName, final InputStream x, final int length) throws SQLException {
  901.         checkOpen();
  902.         try {
  903.             getDelegateCallableStatement().setAsciiStream(parameterName, x, length);
  904.         } catch (final SQLException e) {
  905.             handleException(e);
  906.         }
  907.     }

  909.     @Override
  910.     public void setAsciiStream(final String parameterName, final InputStream inputStream, final long length)
  911.             throws SQLException {
  912.         checkOpen();
  913.         try {
  914.             getDelegateCallableStatement().setAsciiStream(parameterName, inputStream, length);
  915.         } catch (final SQLException e) {
  916.             handleException(e);
  917.         }
  918.     }

  920.     @Override
  921.     public void setBigDecimal(final String parameterName, final BigDecimal x) throws SQLException {
  922.         checkOpen();
  923.         try {
  924.             getDelegateCallableStatement().setBigDecimal(parameterName, x);
  925.         } catch (final SQLException e) {
  926.             handleException(e);
  927.         }
  928.     }

  930.     @Override
  931.     public void setBinaryStream(final String parameterName, final InputStream inputStream) throws SQLException {
  932.         checkOpen();
  933.         try {
  934.             getDelegateCallableStatement().setBinaryStream(parameterName, inputStream);
  935.         } catch (final SQLException e) {
  936.             handleException(e);
  937.         }
  938.     }

  940.     @Override
  941.     public void setBinaryStream(final String parameterName, final InputStream x, final int length) throws SQLException {
  942.         checkOpen();
  943.         try {
  944.             getDelegateCallableStatement().setBinaryStream(parameterName, x, length);
  945.         } catch (final SQLException e) {
  946.             handleException(e);
  947.         }
  948.     }

  950.     @Override
  951.     public void setBinaryStream(final String parameterName, final InputStream inputStream, final long length)
  952.             throws SQLException {
  953.         checkOpen();
  954.         try {
  955.             getDelegateCallableStatement().setBinaryStream(parameterName, inputStream, length);
  956.         } catch (final SQLException e) {
  957.             handleException(e);
  958.         }
  959.     }

  961.     @Override
  962.     public void setBlob(final String parameterName, final Blob blob) throws SQLException {
  963.         checkOpen();
  964.         try {
  965.             getDelegateCallableStatement().setBlob(parameterName, blob);
  966.         } catch (final SQLException e) {
  967.             handleException(e);
  968.         }
  969.     }

  971.     @Override
  972.     public void setBlob(final String parameterName, final InputStream inputStream) throws SQLException {
  973.         checkOpen();
  974.         try {
  975.             getDelegateCallableStatement().setBlob(parameterName, inputStream);
  976.         } catch (final SQLException e) {
  977.             handleException(e);
  978.         }
  979.     }

  981.     @Override
  982.     public void setBlob(final String parameterName, final InputStream inputStream, final long length)
  983.             throws SQLException {
  984.         checkOpen();
  985.         try {
  986.             getDelegateCallableStatement().setBlob(parameterName, inputStream, length);
  987.         } catch (final SQLException e) {
  988.             handleException(e);
  989.         }
  990.     }

  992.     @Override
  993.     public void setBoolean(final String parameterName, final boolean x) throws SQLException {
  994.         checkOpen();
  995.         try {
  996.             getDelegateCallableStatement().setBoolean(parameterName, x);
  997.         } catch (final SQLException e) {
  998.             handleException(e);
  999.         }
  1000.     }

  1002.     @Override
  1003.     public void setByte(final String parameterName, final byte x) throws SQLException {
  1004.         checkOpen();
  1005.         try {
  1006.             getDelegateCallableStatement().setByte(parameterName, x);
  1007.         } catch (final SQLException e) {
  1008.             handleException(e);
  1009.         }
  1010.     }

  1012.     @Override
  1013.     public void setBytes(final String parameterName, final byte[] x) throws SQLException {
  1014.         checkOpen();
  1015.         try {
  1016.             getDelegateCallableStatement().setBytes(parameterName, x);
  1017.         } catch (final SQLException e) {
  1018.             handleException(e);
  1019.         }
  1020.     }

  1022.     @Override
  1023.     public void setCharacterStream(final String parameterName, final Reader reader) throws SQLException {
  1024.         checkOpen();
  1025.         try {
  1026.             getDelegateCallableStatement().setCharacterStream(parameterName, reader);
  1027.         } catch (final SQLException e) {
  1028.             handleException(e);
  1029.         }
  1030.     }

  1032.     @Override
  1033.     public void setCharacterStream(final String parameterName, final Reader reader, final int length)
  1034.             throws SQLException {
  1035.         checkOpen();
  1036.         getDelegateCallableStatement().setCharacterStream(parameterName, reader, length);
  1037.     }

  1039.     @Override
  1040.     public void setCharacterStream(final String parameterName, final Reader reader, final long length)
  1041.             throws SQLException {
  1042.         checkOpen();
  1043.         try {
  1044.             getDelegateCallableStatement().setCharacterStream(parameterName, reader, length);
  1045.         } catch (final SQLException e) {
  1046.             handleException(e);
  1047.         }
  1048.     }

  1050.     @Override
  1051.     public void setClob(final String parameterName, final Clob clob) throws SQLException {
  1052.         checkOpen();
  1053.         try {
  1054.             getDelegateCallableStatement().setClob(parameterName, clob);
  1055.         } catch (final SQLException e) {
  1056.             handleException(e);
  1057.         }
  1058.     }

  1060.     @Override
  1061.     public void setClob(final String parameterName, final Reader reader) throws SQLException {
  1062.         checkOpen();
  1063.         try {
  1064.             getDelegateCallableStatement().setClob(parameterName, reader);
  1065.         } catch (final SQLException e) {
  1066.             handleException(e);
  1067.         }
  1068.     }

  1070.     @Override
  1071.     public void setClob(final String parameterName, final Reader reader, final long length) throws SQLException {
  1072.         checkOpen();
  1073.         try {
  1074.             getDelegateCallableStatement().setClob(parameterName, reader, length);
  1075.         } catch (final SQLException e) {
  1076.             handleException(e);
  1077.         }
  1078.     }

  1080.     @Override
  1081.     public void setDate(final String parameterName, final Date x) throws SQLException {
  1082.         checkOpen();
  1083.         try {
  1084.             getDelegateCallableStatement().setDate(parameterName, x);
  1085.         } catch (final SQLException e) {
  1086.             handleException(e);
  1087.         }
  1088.     }

  1090.     @Override
  1091.     public void setDate(final String parameterName, final Date x, final Calendar cal) throws SQLException {
  1092.         checkOpen();
  1093.         try {
  1094.             getDelegateCallableStatement().setDate(parameterName, x, cal);
  1095.         } catch (final SQLException e) {
  1096.             handleException(e);
  1097.         }
  1098.     }

  1100.     @Override
  1101.     public void setDouble(final String parameterName, final double x) throws SQLException {
  1102.         checkOpen();
  1103.         try {
  1104.             getDelegateCallableStatement().setDouble(parameterName, x);
  1105.         } catch (final SQLException e) {
  1106.             handleException(e);
  1107.         }
  1108.     }

  1110.     @Override
  1111.     public void setFloat(final String parameterName, final float x) throws SQLException {
  1112.         checkOpen();
  1113.         try {
  1114.             getDelegateCallableStatement().setFloat(parameterName, x);
  1115.         } catch (final SQLException e) {
  1116.             handleException(e);
  1117.         }
  1118.     }

  1120.     @Override
  1121.     public void setInt(final String parameterName, final int x) throws SQLException {
  1122.         checkOpen();
  1123.         try {
  1124.             getDelegateCallableStatement().setInt(parameterName, x);
  1125.         } catch (final SQLException e) {
  1126.             handleException(e);
  1127.         }
  1128.     }

  1130.     @Override
  1131.     public void setLong(final String parameterName, final long x) throws SQLException {
  1132.         checkOpen();
  1133.         try {
  1134.             getDelegateCallableStatement().setLong(parameterName, x);
  1135.         } catch (final SQLException e) {
  1136.             handleException(e);
  1137.         }
  1138.     }

  1140.     @Override
  1141.     public void setNCharacterStream(final String parameterName, final Reader reader) throws SQLException {
  1142.         checkOpen();
  1143.         try {
  1144.             getDelegateCallableStatement().setNCharacterStream(parameterName, reader);
  1145.         } catch (final SQLException e) {
  1146.             handleException(e);
  1147.         }
  1148.     }

  1150.     @Override
  1151.     public void setNCharacterStream(final String parameterName, final Reader reader, final long length)
  1152.             throws SQLException {
  1153.         checkOpen();
  1154.         try {
  1155.             getDelegateCallableStatement().setNCharacterStream(parameterName, reader, length);
  1156.         } catch (final SQLException e) {
  1157.             handleException(e);
  1158.         }
  1159.     }

  1161.     @Override
  1162.     public void setNClob(final String parameterName, final NClob value) throws SQLException {
  1163.         checkOpen();
  1164.         try {
  1165.             getDelegateCallableStatement().setNClob(parameterName, value);
  1166.         } catch (final SQLException e) {
  1167.             handleException(e);
  1168.         }
  1169.     }

  1171.     @Override
  1172.     public void setNClob(final String parameterName, final Reader reader) throws SQLException {
  1173.         checkOpen();
  1174.         try {
  1175.             getDelegateCallableStatement().setNClob(parameterName, reader);
  1176.         } catch (final SQLException e) {
  1177.             handleException(e);
  1178.         }
  1179.     }

  1181.     @Override
  1182.     public void setNClob(final String parameterName, final Reader reader, final long length) throws SQLException {
  1183.         checkOpen();
  1184.         try {
  1185.             getDelegateCallableStatement().setNClob(parameterName, reader, length);
  1186.         } catch (final SQLException e) {
  1187.             handleException(e);
  1188.         }
  1189.     }

  1191.     @Override
  1192.     public void setNString(final String parameterName, final String value) throws SQLException {
  1193.         checkOpen();
  1194.         try {
  1195.             getDelegateCallableStatement().setNString(parameterName, value);
  1196.         } catch (final SQLException e) {
  1197.             handleException(e);
  1198.         }
  1199.     }

  1201.     @Override
  1202.     public void setNull(final String parameterName, final int sqlType) throws SQLException {
  1203.         checkOpen();
  1204.         try {
  1205.             getDelegateCallableStatement().setNull(parameterName, sqlType);
  1206.         } catch (final SQLException e) {
  1207.             handleException(e);
  1208.         }
  1209.     }

  1211.     @Override
  1212.     public void setNull(final String parameterName, final int sqlType, final String typeName) throws SQLException {
  1213.         checkOpen();
  1214.         try {
  1215.             getDelegateCallableStatement().setNull(parameterName, sqlType, typeName);
  1216.         } catch (final SQLException e) {
  1217.             handleException(e);
  1218.         }
  1219.     }

  1221.     @Override
  1222.     public void setObject(final String parameterName, final Object x) throws SQLException {
  1223.         checkOpen();
  1224.         try {
  1225.             getDelegateCallableStatement().setObject(parameterName, x);
  1226.         } catch (final SQLException e) {
  1227.             handleException(e);
  1228.         }
  1229.     }

  1231.     @Override
  1232.     public void setObject(final String parameterName, final Object x, final int targetSqlType) throws SQLException {
  1233.         checkOpen();
  1234.         try {
  1235.             getDelegateCallableStatement().setObject(parameterName, x, targetSqlType);
  1236.         } catch (final SQLException e) {
  1237.             handleException(e);
  1238.         }
  1239.     }

  1241.     @Override
  1242.     public void setObject(final String parameterName, final Object x, final int targetSqlType, final int scale)
  1243.             throws SQLException {
  1244.         checkOpen();
  1245.         try {
  1246.             getDelegateCallableStatement().setObject(parameterName, x, targetSqlType, scale);
  1247.         } catch (final SQLException e) {
  1248.             handleException(e);
  1249.         }
  1250.     }

  1252.     /**
  1253.      * @since 2.5.0
  1254.      */
  1255.     @Override
  1256.     public void setObject(final String parameterName, final Object x, final SQLType targetSqlType) throws SQLException {
  1257.         checkOpen();
  1258.         try {
  1259.             getDelegateCallableStatement().setObject(parameterName, x, targetSqlType);
  1260.         } catch (final SQLException e) {
  1261.             handleException(e);
  1262.         }
  1263.     }

  1265.     /**
  1266.      * @since 2.5.0
  1267.      */
  1268.     @Override
  1269.     public void setObject(final String parameterName, final Object x, final SQLType targetSqlType,
  1270.             final int scaleOrLength) throws SQLException {
  1271.         checkOpen();
  1272.         try {
  1273.             getDelegateCallableStatement().setObject(parameterName, x, targetSqlType, scaleOrLength);
  1274.         } catch (final SQLException e) {
  1275.             handleException(e);
  1276.         }
  1277.     }

  1279.     @Override
  1280.     public void setRowId(final String parameterName, final RowId value) throws SQLException {
  1281.         checkOpen();
  1282.         try {
  1283.             getDelegateCallableStatement().setRowId(parameterName, value);
  1284.         } catch (final SQLException e) {
  1285.             handleException(e);
  1286.         }
  1287.     }

  1289.     @Override
  1290.     public void setShort(final String parameterName, final short x) throws SQLException {
  1291.         checkOpen();
  1292.         try {
  1293.             getDelegateCallableStatement().setShort(parameterName, x);
  1294.         } catch (final SQLException e) {
  1295.             handleException(e);
  1296.         }
  1297.     }

  1299.     @Override
  1300.     public void setSQLXML(final String parameterName, final SQLXML value) throws SQLException {
  1301.         checkOpen();
  1302.         try {
  1303.             getDelegateCallableStatement().setSQLXML(parameterName, value);
  1304.         } catch (final SQLException e) {
  1305.             handleException(e);
  1306.         }
  1307.     }

  1309.     @Override
  1310.     public void setString(final String parameterName, final String x) throws SQLException {
  1311.         checkOpen();
  1312.         try {
  1313.             getDelegateCallableStatement().setString(parameterName, x);
  1314.         } catch (final SQLException e) {
  1315.             handleException(e);
  1316.         }
  1317.     }

  1319.     @Override
  1320.     public void setTime(final String parameterName, final Time x) throws SQLException {
  1321.         checkOpen();
  1322.         try {
  1323.             getDelegateCallableStatement().setTime(parameterName, x);
  1324.         } catch (final SQLException e) {
  1325.             handleException(e);
  1326.         }
  1327.     }

  1329.     @Override
  1330.     public void setTime(final String parameterName, final Time x, final Calendar cal) throws SQLException {
  1331.         checkOpen();
  1332.         try {
  1333.             getDelegateCallableStatement().setTime(parameterName, x, cal);
  1334.         } catch (final SQLException e) {
  1335.             handleException(e);
  1336.         }
  1337.     }

  1339.     @Override
  1340.     public void setTimestamp(final String parameterName, final Timestamp x) throws SQLException {
  1341.         checkOpen();
  1342.         try {
  1343.             getDelegateCallableStatement().setTimestamp(parameterName, x);
  1344.         } catch (final SQLException e) {
  1345.             handleException(e);
  1346.         }
  1347.     }

  1349.     @Override
  1350.     public void setTimestamp(final String parameterName, final Timestamp x, final Calendar cal) throws SQLException {
  1351.         checkOpen();
  1352.         try {
  1353.             getDelegateCallableStatement().setTimestamp(parameterName, x, cal);
  1354.         } catch (final SQLException e) {
  1355.             handleException(e);
  1356.         }
  1357.     }

  1359.     @Override
  1360.     public void setURL(final String parameterName, final URL val) throws SQLException {
  1361.         checkOpen();
  1362.         try {
  1363.             getDelegateCallableStatement().setURL(parameterName, val);
  1364.         } catch (final SQLException e) {
  1365.             handleException(e);
  1366.         }
  1367.     }

  1369.     @Override
  1370.     public boolean wasNull() throws SQLException {
  1371.         checkOpen();
  1372.         try {
  1373.             return getDelegateCallableStatement().wasNull();
  1374.         } catch (final SQLException e) {
  1375.             handleException(e);
  1376.             return false;
  1377.         }
  1378.     }

  1380. }
Created with JaCoCo 0.8.12.202403310830