Clover coverage report - brownies library - 1.0-beta-1
Coverage timestamp: 月 8 16 2004 17:14:42 GMT+09:00
file stats: LOC: 849   Methods: 83
NCLOC: 320   Classes: 1
30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover
 
 Source file Conditionals Statements Methods TOTAL
LogCallableStatement.java 0% 0% 0% 0%
coverage
 1   
 /*
 2   
  * Joey and its relative products are published under the terms
 3   
  * of the Apache Software License.
 4   
  */
 5   
 /*
 6   
  * Created on 2004/03/01
 7   
  */
 8   
 package org.asyrinx.brownie.jdbc.logger;
 9   
 
 10   
 import java.io.InputStream;
 11   
 import java.io.Reader;
 12   
 import java.math.BigDecimal;
 13   
 import java.net.URL;
 14   
 import java.sql.Array;
 15   
 import java.sql.Blob;
 16   
 import java.sql.CallableStatement;
 17   
 import java.sql.Clob;
 18   
 import java.sql.Date;
 19   
 import java.sql.Ref;
 20   
 import java.sql.SQLException;
 21   
 import java.sql.Time;
 22   
 import java.sql.Timestamp;
 23   
 import java.util.Calendar;
 24   
 import java.util.HashMap;
 25   
 import java.util.Map;
 26   
 
 27   
 import org.asyrinx.brownie.core.collection.MapUtils;
 28   
 import org.asyrinx.brownie.core.collection.StringKeyMap;
 29   
 import org.asyrinx.brownie.core.log.CascadeNamedLog;
 30   
 
 31   
 /**
 32   
  * @author akima
 33   
  */
 34   
 public class LogCallableStatement extends LogPreparedStatement implements
 35   
         CallableStatement {
 36   
     /**
 37   
      * @param wrapped
 38   
      */
 39  0
     public LogCallableStatement(CallableStatement wrapped, String sql,
 40   
             CascadeNamedLog parentLog) {
 41  0
         super(wrapped, sql, parentLog);
 42  0
         this.wrapped = wrapped;
 43   
     }
 44   
 
 45   
     private final CallableStatement wrapped;
 46   
 
 47   
     private final StringKeyMap parameters = MapUtils
 48   
             .toStringKeyMap(new HashMap());
 49   
 
 50  0
     protected final void addParam(String paramName, Object value) {
 51  0
         parameters.put(paramName, value);
 52   
     }
 53   
 
 54  0
     protected String formatSql() {
 55   
         //パラメータ名で指定されてなかったら番号で指定されたものとしてSQLを編集
 56  0
         if (this.parameters.isEmpty())
 57  0
             return super.formatSql();
 58   
         else
 59  0
             return replacer.execute(this.sql, this.parameters);
 60   
     }
 61   
 
 62   
     /**
 63   
      * @throws java.sql.SQLException
 64   
      */
 65  0
     public void clearParameters() throws SQLException {
 66  0
         super.clearParameters();
 67  0
         parameters.clear();
 68   
     }
 69   
 
 70   
     /**
 71   
      * @param i
 72   
      * @return @throws
 73   
      *         java.sql.SQLException
 74   
      */
 75  0
     public Array getArray(int parameterIndex) throws SQLException {
 76  0
         return wrapped.getArray(parameterIndex);
 77   
     }
 78   
 
 79   
     /**
 80   
      * @param parameterName
 81   
      * @return @throws
 82   
      *         java.sql.SQLException
 83   
      */
 84  0
     public Array getArray(String parameterName) throws SQLException {
 85  0
         return wrapped.getArray(parameterName);
 86   
     }
 87   
 
 88   
     /**
 89   
      * @param parameterIndex
 90   
      * @return @throws
 91   
      *         java.sql.SQLException
 92   
      */
 93  0
     public BigDecimal getBigDecimal(int parameterIndex) throws SQLException {
 94  0
         return wrapped.getBigDecimal(parameterIndex);
 95   
     }
 96   
 
 97   
     /**
 98   
      * @param parameterIndex
 99   
      * @param scale
 100   
      * @return @throws
 101   
      *         java.sql.SQLException
 102   
      * @deprecated
 103   
      */
 104  0
     public BigDecimal getBigDecimal(int parameterIndex, int scale)
 105   
             throws SQLException {
 106  0
         return wrapped.getBigDecimal(parameterIndex, scale);
 107   
     }
 108   
 
 109   
     /**
 110   
      * @param parameterName
 111   
      * @return @throws
 112   
      *         java.sql.SQLException
 113   
      */
 114  0
     public BigDecimal getBigDecimal(String parameterName) throws SQLException {
 115  0
         return wrapped.getBigDecimal(parameterName);
 116   
     }
 117   
 
 118   
     /**
 119   
      * @param i
 120   
      * @return @throws
 121   
      *         java.sql.SQLException
 122   
      */
 123  0
     public Blob getBlob(int parameterIndex) throws SQLException {
 124  0
         return wrapped.getBlob(parameterIndex);
 125   
     }
 126   
 
 127   
     /**
 128   
      * @param parameterName
 129   
      * @return @throws
 130   
      *         java.sql.SQLException
 131   
      */
 132  0
     public Blob getBlob(String parameterName) throws SQLException {
 133  0
         return wrapped.getBlob(parameterName);
 134   
     }
 135   
 
 136   
     /**
 137   
      * @param parameterIndex
 138   
      * @return @throws
 139   
      *         java.sql.SQLException
 140   
      */
 141  0
     public boolean getBoolean(int parameterIndex) throws SQLException {
 142  0
         return wrapped.getBoolean(parameterIndex);
 143   
     }
 144   
 
 145   
     /**
 146   
      * @param parameterName
 147   
      * @return @throws
 148   
      *         java.sql.SQLException
 149   
      */
 150  0
     public boolean getBoolean(String parameterName) throws SQLException {
 151  0
         return wrapped.getBoolean(parameterName);
 152   
     }
 153   
 
 154   
     /**
 155   
      * @param parameterIndex
 156   
      * @return @throws
 157   
      *         java.sql.SQLException
 158   
      */
 159  0
     public byte getByte(int parameterIndex) throws SQLException {
 160  0
         return wrapped.getByte(parameterIndex);
 161   
     }
 162   
 
 163   
     /**
 164   
      * @param parameterName
 165   
      * @return @throws
 166   
      *         java.sql.SQLException
 167   
      */
 168  0
     public byte getByte(String parameterName) throws SQLException {
 169  0
         return wrapped.getByte(parameterName);
 170   
     }
 171   
 
 172   
     /**
 173   
      * @param parameterIndex
 174   
      * @return @throws
 175   
      *         java.sql.SQLException
 176   
      */
 177  0
     public byte[] getBytes(int parameterIndex) throws SQLException {
 178  0
         return wrapped.getBytes(parameterIndex);
 179   
     }
 180   
 
 181   
     /**
 182   
      * @param parameterName
 183   
      * @return @throws
 184   
      *         java.sql.SQLException
 185   
      */
 186  0
     public byte[] getBytes(String parameterName) throws SQLException {
 187  0
         return wrapped.getBytes(parameterName);
 188   
     }
 189   
 
 190   
     /**
 191   
      * @param i
 192   
      * @return @throws
 193   
      *         java.sql.SQLException
 194   
      */
 195  0
     public Clob getClob(int parameterIndex) throws SQLException {
 196  0
         return wrapped.getClob(parameterIndex);
 197   
     }
 198   
 
 199   
     /**
 200   
      * @param parameterName
 201   
      * @return @throws
 202   
      *         java.sql.SQLException
 203   
      */
 204  0
     public Clob getClob(String parameterName) throws SQLException {
 205  0
         return wrapped.getClob(parameterName);
 206   
     }
 207   
 
 208   
     /**
 209   
      * @param parameterIndex
 210   
      * @return @throws
 211   
      *         java.sql.SQLException
 212   
      */
 213  0
     public Date getDate(int parameterIndex) throws SQLException {
 214  0
         return wrapped.getDate(parameterIndex);
 215   
     }
 216   
 
 217   
     /**
 218   
      * @param parameterIndex
 219   
      * @param cal
 220   
      * @return @throws
 221   
      *         java.sql.SQLException
 222   
      */
 223  0
     public Date getDate(int parameterIndex, Calendar cal) throws SQLException {
 224  0
         return wrapped.getDate(parameterIndex, cal);
 225   
     }
 226   
 
 227   
     /**
 228   
      * @param parameterName
 229   
      * @return @throws
 230   
      *         java.sql.SQLException
 231   
      */
 232  0
     public Date getDate(String parameterName) throws SQLException {
 233  0
         return wrapped.getDate(parameterName);
 234   
     }
 235   
 
 236   
     /**
 237   
      * @param parameterName
 238   
      * @param cal
 239   
      * @return @throws
 240   
      *         java.sql.SQLException
 241   
      */
 242  0
     public Date getDate(String parameterName, Calendar cal) throws SQLException {
 243  0
         return wrapped.getDate(parameterName, cal);
 244   
     }
 245   
 
 246   
     /**
 247   
      * @param parameterIndex
 248   
      * @return @throws
 249   
      *         java.sql.SQLException
 250   
      */
 251  0
     public double getDouble(int parameterIndex) throws SQLException {
 252  0
         return wrapped.getDouble(parameterIndex);
 253   
     }
 254   
 
 255   
     /**
 256   
      * @param parameterName
 257   
      * @return @throws
 258   
      *         java.sql.SQLException
 259   
      */
 260  0
     public double getDouble(String parameterName) throws SQLException {
 261  0
         return wrapped.getDouble(parameterName);
 262   
     }
 263   
 
 264   
     /**
 265   
      * @param parameterIndex
 266   
      * @return @throws
 267   
      *         java.sql.SQLException
 268   
      */
 269  0
     public float getFloat(int parameterIndex) throws SQLException {
 270  0
         return wrapped.getFloat(parameterIndex);
 271   
     }
 272   
 
 273   
     /**
 274   
      * @param parameterName
 275   
      * @return @throws
 276   
      *         java.sql.SQLException
 277   
      */
 278  0
     public float getFloat(String parameterName) throws SQLException {
 279  0
         return wrapped.getFloat(parameterName);
 280   
     }
 281   
 
 282   
     /**
 283   
      * @param parameterIndex
 284   
      * @return @throws
 285   
      *         java.sql.SQLException
 286   
      */
 287  0
     public int getInt(int parameterIndex) throws SQLException {
 288  0
         return wrapped.getInt(parameterIndex);
 289   
     }
 290   
 
 291   
     /**
 292   
      * @param parameterName
 293   
      * @return @throws
 294   
      *         java.sql.SQLException
 295   
      */
 296  0
     public int getInt(String parameterName) throws SQLException {
 297  0
         return wrapped.getInt(parameterName);
 298   
     }
 299   
 
 300   
     /**
 301   
      * @param parameterIndex
 302   
      * @return @throws
 303   
      *         java.sql.SQLException
 304   
      */
 305  0
     public long getLong(int parameterIndex) throws SQLException {
 306  0
         return wrapped.getLong(parameterIndex);
 307   
     }
 308   
 
 309   
     /**
 310   
      * @param parameterName
 311   
      * @return @throws
 312   
      *         java.sql.SQLException
 313   
      */
 314  0
     public long getLong(String parameterName) throws SQLException {
 315  0
         return wrapped.getLong(parameterName);
 316   
     }
 317   
 
 318   
     /**
 319   
      * @param parameterIndex
 320   
      * @return @throws
 321   
      *         java.sql.SQLException
 322   
      */
 323  0
     public Object getObject(int parameterIndex) throws SQLException {
 324  0
         return wrapped.getObject(parameterIndex);
 325   
     }
 326   
 
 327   
     /**
 328   
      * @param i
 329   
      * @param map
 330   
      * @return @throws
 331   
      *         java.sql.SQLException
 332   
      */
 333  0
     public Object getObject(int parameterIndex, Map map) throws SQLException {
 334  0
         return wrapped.getObject(parameterIndex, map);
 335   
     }
 336   
 
 337   
     /**
 338   
      * @param parameterName
 339   
      * @return @throws
 340   
      *         java.sql.SQLException
 341   
      */
 342  0
     public Object getObject(String parameterName) throws SQLException {
 343  0
         return wrapped.getObject(parameterName);
 344   
     }
 345   
 
 346   
     /**
 347   
      * @param parameterName
 348   
      * @param map
 349   
      * @return @throws
 350   
      *         java.sql.SQLException
 351   
      */
 352  0
     public Object getObject(String parameterName, Map map) throws SQLException {
 353  0
         return wrapped.getObject(parameterName, map);
 354   
     }
 355   
 
 356   
     /**
 357   
      * @param i
 358   
      * @return @throws
 359   
      *         java.sql.SQLException
 360   
      */
 361  0
     public Ref getRef(int parameterIndex) throws SQLException {
 362  0
         return wrapped.getRef(parameterIndex);
 363   
     }
 364   
 
 365   
     /**
 366   
      * @param parameterName
 367   
      * @return @throws
 368   
      *         java.sql.SQLException
 369   
      */
 370  0
     public Ref getRef(String parameterName) throws SQLException {
 371  0
         return wrapped.getRef(parameterName);
 372   
     }
 373   
 
 374   
     /**
 375   
      * @param parameterIndex
 376   
      * @return @throws
 377   
      *         java.sql.SQLException
 378   
      */
 379  0
     public short getShort(int parameterIndex) throws SQLException {
 380  0
         return wrapped.getShort(parameterIndex);
 381   
     }
 382   
 
 383   
     /**
 384   
      * @param parameterName
 385   
      * @return @throws
 386   
      *         java.sql.SQLException
 387   
      */
 388  0
     public short getShort(String parameterName) throws SQLException {
 389  0
         return wrapped.getShort(parameterName);
 390   
     }
 391   
 
 392   
     /**
 393   
      * @param parameterIndex
 394   
      * @return @throws
 395   
      *         java.sql.SQLException
 396   
      */
 397  0
     public String getString(int parameterIndex) throws SQLException {
 398  0
         return wrapped.getString(parameterIndex);
 399   
     }
 400   
 
 401   
     /**
 402   
      * @param parameterName
 403   
      * @return @throws
 404   
      *         java.sql.SQLException
 405   
      */
 406  0
     public String getString(String parameterName) throws SQLException {
 407  0
         return wrapped.getString(parameterName);
 408   
     }
 409   
 
 410   
     /**
 411   
      * @param parameterIndex
 412   
      * @return @throws
 413   
      *         java.sql.SQLException
 414   
      */
 415  0
     public Time getTime(int parameterIndex) throws SQLException {
 416  0
         return wrapped.getTime(parameterIndex);
 417   
     }
 418   
 
 419   
     /**
 420   
      * @param parameterIndex
 421   
      * @param cal
 422   
      * @return @throws
 423   
      *         java.sql.SQLException
 424   
      */
 425  0
     public Time getTime(int parameterIndex, Calendar cal) throws SQLException {
 426  0
         return wrapped.getTime(parameterIndex, cal);
 427   
     }
 428   
 
 429   
     /**
 430   
      * @param parameterName
 431   
      * @return @throws
 432   
      *         java.sql.SQLException
 433   
      */
 434  0
     public Time getTime(String parameterName) throws SQLException {
 435  0
         return wrapped.getTime(parameterName);
 436   
     }
 437   
 
 438   
     /**
 439   
      * @param parameterName
 440   
      * @param cal
 441   
      * @return @throws
 442   
      *         java.sql.SQLException
 443   
      */
 444  0
     public Time getTime(String parameterName, Calendar cal) throws SQLException {
 445  0
         return wrapped.getTime(parameterName, cal);
 446   
     }
 447   
 
 448   
     /**
 449   
      * @param parameterIndex
 450   
      * @return @throws
 451   
      *         java.sql.SQLException
 452   
      */
 453  0
     public Timestamp getTimestamp(int parameterIndex) throws SQLException {
 454  0
         return wrapped.getTimestamp(parameterIndex);
 455   
     }
 456   
 
 457   
     /**
 458   
      * @param parameterIndex
 459   
      * @param cal
 460   
      * @return @throws
 461   
      *         java.sql.SQLException
 462   
      */
 463  0
     public Timestamp getTimestamp(int parameterIndex, Calendar cal)
 464   
             throws SQLException {
 465  0
         return wrapped.getTimestamp(parameterIndex, cal);
 466   
     }
 467   
 
 468   
     /**
 469   
      * @param parameterName
 470   
      * @return @throws
 471   
      *         java.sql.SQLException
 472   
      */
 473  0
     public Timestamp getTimestamp(String parameterName) throws SQLException {
 474  0
         return wrapped.getTimestamp(parameterName);
 475   
     }
 476   
 
 477   
     /**
 478   
      * @param parameterName
 479   
      * @param cal
 480   
      * @return @throws
 481   
      *         java.sql.SQLException
 482   
      */
 483  0
     public Timestamp getTimestamp(String parameterName, Calendar cal)
 484   
             throws SQLException {
 485  0
         return wrapped.getTimestamp(parameterName, cal);
 486   
     }
 487   
 
 488   
     /**
 489   
      * @param parameterIndex
 490   
      * @return @throws
 491   
      *         java.sql.SQLException
 492   
      */
 493  0
     public URL getURL(int parameterIndex) throws SQLException {
 494  0
         return wrapped.getURL(parameterIndex);
 495   
     }
 496   
 
 497   
     /**
 498   
      * @param parameterName
 499   
      * @return @throws
 500   
      *         java.sql.SQLException
 501   
      */
 502  0
     public URL getURL(String parameterName) throws SQLException {
 503  0
         return wrapped.getURL(parameterName);
 504   
     }
 505   
 
 506   
     /**
 507   
      * @param parameterIndex
 508   
      * @param sqlType
 509   
      * @throws java.sql.SQLException
 510   
      */
 511  0
     public void registerOutParameter(int parameterIndex, int sqlType)
 512   
             throws SQLException {
 513  0
         wrapped.registerOutParameter(parameterIndex, sqlType);
 514   
     }
 515   
 
 516   
     /**
 517   
      * @param parameterIndex
 518   
      * @param sqlType
 519   
      * @param scale
 520   
      * @throws java.sql.SQLException
 521   
      */
 522  0
     public void registerOutParameter(int parameterIndex, int sqlType, int scale)
 523   
             throws SQLException {
 524  0
         wrapped.registerOutParameter(parameterIndex, sqlType, scale);
 525   
     }
 526   
 
 527   
     /**
 528   
      * @param paramIndex
 529   
      * @param sqlType
 530   
      * @param typeName
 531   
      * @throws java.sql.SQLException
 532   
      */
 533  0
     public void registerOutParameter(int paramIndex, int sqlType,
 534   
             String typeName) throws SQLException {
 535  0
         wrapped.registerOutParameter(paramIndex, sqlType, typeName);
 536   
     }
 537   
 
 538   
     /**
 539   
      * @param parameterName
 540   
      * @param sqlType
 541   
      * @throws java.sql.SQLException
 542   
      */
 543  0
     public void registerOutParameter(String parameterName, int sqlType)
 544   
             throws SQLException {
 545  0
         wrapped.registerOutParameter(parameterName, sqlType);
 546   
     }
 547   
 
 548   
     /**
 549   
      * @param parameterName
 550   
      * @param sqlType
 551   
      * @param scale
 552   
      * @throws java.sql.SQLException
 553   
      */
 554  0
     public void registerOutParameter(String parameterName, int sqlType,
 555   
             int scale) throws SQLException {
 556  0
         wrapped.registerOutParameter(parameterName, sqlType, scale);
 557   
     }
 558   
 
 559   
     /**
 560   
      * @param parameterName
 561   
      * @param sqlType
 562   
      * @param typeName
 563   
      * @throws java.sql.SQLException
 564   
      */
 565  0
     public void registerOutParameter(String parameterName, int sqlType,
 566   
             String typeName) throws SQLException {
 567  0
         wrapped.registerOutParameter(parameterName, sqlType, typeName);
 568   
     }
 569   
 
 570   
     /**
 571   
      * @param parameterName
 572   
      * @param x
 573   
      * @param length
 574   
      * @throws java.sql.SQLException
 575   
      */
 576  0
     public void setAsciiStream(String parameterName, InputStream x, int length)
 577   
             throws SQLException {
 578  0
         wrapped.setAsciiStream(parameterName, x, length);
 579   
         //addParam(parameterName, x);
 580   
     }
 581   
 
 582   
     /**
 583   
      * @param parameterName
 584   
      * @param x
 585   
      * @throws java.sql.SQLException
 586   
      */
 587  0
     public void setBigDecimal(String parameterName, BigDecimal x)
 588   
             throws SQLException {
 589  0
         wrapped.setBigDecimal(parameterName, x);
 590  0
         addParam(parameterName, x);
 591   
     }
 592   
 
 593   
     /**
 594   
      * @param parameterName
 595   
      * @param x
 596   
      * @param length
 597   
      * @throws java.sql.SQLException
 598   
      */
 599  0
     public void setBinaryStream(String parameterName, InputStream x, int length)
 600   
             throws SQLException {
 601  0
         wrapped.setBinaryStream(parameterName, x, length);
 602   
         //addParam(parameterName, x);
 603   
     }
 604   
 
 605   
     /**
 606   
      * @param parameterName
 607   
      * @param x
 608   
      * @throws java.sql.SQLException
 609   
      */
 610  0
     public void setBoolean(String parameterName, boolean x) throws SQLException {
 611  0
         wrapped.setBoolean(parameterName, x);
 612  0
         addParam(parameterName, new Boolean(x));
 613   
     }
 614   
 
 615   
     /**
 616   
      * @param parameterName
 617   
      * @param x
 618   
      * @throws java.sql.SQLException
 619   
      */
 620  0
     public void setByte(String parameterName, byte x) throws SQLException {
 621  0
         wrapped.setByte(parameterName, x);
 622  0
         addParam(parameterName, new Byte(x));
 623   
     }
 624   
 
 625   
     /**
 626   
      * @param parameterName
 627   
      * @param x
 628   
      * @throws java.sql.SQLException
 629   
      */
 630  0
     public void setBytes(String parameterName, byte[] x) throws SQLException {
 631  0
         wrapped.setBytes(parameterName, x);
 632  0
         addParam(parameterName, x);
 633   
     }
 634   
 
 635   
     /**
 636   
      * @param parameterName
 637   
      * @param reader
 638   
      * @param length
 639   
      * @throws java.sql.SQLException
 640   
      */
 641  0
     public void setCharacterStream(String parameterName, Reader reader,
 642   
             int length) throws SQLException {
 643  0
         wrapped.setCharacterStream(parameterName, reader, length);
 644   
         //addParam(parameterName, x);
 645   
     }
 646   
 
 647   
     /**
 648   
      * @param parameterName
 649   
      * @param x
 650   
      * @throws java.sql.SQLException
 651   
      */
 652  0
     public void setDate(String parameterName, Date x) throws SQLException {
 653  0
         wrapped.setDate(parameterName, x);
 654  0
         addParam(parameterName, x);
 655   
     }
 656   
 
 657   
     /**
 658   
      * @param parameterName
 659   
      * @param x
 660   
      * @param cal
 661   
      * @throws java.sql.SQLException
 662   
      */
 663  0
     public void setDate(String parameterName, Date x, Calendar cal)
 664   
             throws SQLException {
 665  0
         wrapped.setDate(parameterName, x, cal);
 666  0
         addParam(parameterName, x);
 667   
     }
 668   
 
 669   
     /**
 670   
      * @param parameterName
 671   
      * @param x
 672   
      * @throws java.sql.SQLException
 673   
      */
 674  0
     public void setDouble(String parameterName, double x) throws SQLException {
 675  0
         wrapped.setDouble(parameterName, x);
 676  0
         addParam(parameterName, new Double(x));
 677   
     }
 678   
 
 679   
     /**
 680   
      * @param parameterName
 681   
      * @param x
 682   
      * @throws java.sql.SQLException
 683   
      */
 684  0
     public void setFloat(String parameterName, float x) throws SQLException {
 685  0
         wrapped.setFloat(parameterName, x);
 686  0
         addParam(parameterName, new Float(x));
 687   
     }
 688   
 
 689   
     /**
 690   
      * @param parameterName
 691   
      * @param x
 692   
      * @throws java.sql.SQLException
 693   
      */
 694  0
     public void setInt(String parameterName, int x) throws SQLException {
 695  0
         wrapped.setInt(parameterName, x);
 696  0
         addParam(parameterName, new Integer(x));
 697   
     }
 698   
 
 699   
     /**
 700   
      * @param parameterName
 701   
      * @param x
 702   
      * @throws java.sql.SQLException
 703   
      */
 704  0
     public void setLong(String parameterName, long x) throws SQLException {
 705  0
         wrapped.setLong(parameterName, x);
 706  0
         addParam(parameterName, new Long(x));
 707   
     }
 708   
 
 709   
     /**
 710   
      * @param parameterName
 711   
      * @param sqlType
 712   
      * @throws java.sql.SQLException
 713   
      */
 714  0
     public void setNull(String parameterName, int sqlType) throws SQLException {
 715  0
         wrapped.setNull(parameterName, sqlType);
 716   
         //addParam(parameterName, null);
 717   
     }
 718   
 
 719   
     /**
 720   
      * @param parameterName
 721   
      * @param sqlType
 722   
      * @param typeName
 723   
      * @throws java.sql.SQLException
 724   
      */
 725  0
     public void setNull(String parameterName, int sqlType, String typeName)
 726   
             throws SQLException {
 727  0
         wrapped.setNull(parameterName, sqlType, typeName);
 728   
         //addParam(parameterName, null);
 729   
     }
 730   
 
 731   
     /**
 732   
      * @param parameterName
 733   
      * @param x
 734   
      * @throws java.sql.SQLException
 735   
      */
 736  0
     public void setObject(String parameterName, Object x) throws SQLException {
 737  0
         wrapped.setObject(parameterName, x);
 738  0
         addParam(parameterName, x);
 739   
     }
 740   
 
 741   
     /**
 742   
      * @param parameterName
 743   
      * @param x
 744   
      * @param targetSqlType
 745   
      * @throws java.sql.SQLException
 746   
      */
 747  0
     public void setObject(String parameterName, Object x, int targetSqlType)
 748   
             throws SQLException {
 749  0
         wrapped.setObject(parameterName, x, targetSqlType);
 750  0
         addParam(parameterName, x);
 751   
     }
 752   
 
 753   
     /**
 754   
      * @param parameterName
 755   
      * @param x
 756   
      * @param targetSqlType
 757   
      * @param scale
 758   
      * @throws java.sql.SQLException
 759   
      */
 760  0
     public void setObject(String parameterName, Object x, int targetSqlType,
 761   
             int scale) throws SQLException {
 762  0
         wrapped.setObject(parameterName, x, targetSqlType, scale);
 763  0
         addParam(parameterName, x);
 764   
     }
 765   
 
 766   
     /**
 767   
      * @param parameterName
 768   
      * @param x
 769   
      * @throws java.sql.SQLException
 770   
      */
 771  0
     public void setShort(String parameterName, short x) throws SQLException {
 772  0
         wrapped.setShort(parameterName, x);
 773  0
         addParam(parameterName, new Short(x));
 774   
     }
 775   
 
 776   
     /**
 777   
      * @param parameterName
 778   
      * @param x
 779   
      * @throws java.sql.SQLException
 780   
      */
 781  0
     public void setString(String parameterName, String x) throws SQLException {
 782  0
         wrapped.setString(parameterName, x);
 783  0
         addParam(parameterName, x);
 784   
     }
 785   
 
 786   
     /**
 787   
      * @param parameterName
 788   
      * @param x
 789   
      * @throws java.sql.SQLException
 790   
      */
 791  0
     public void setTime(String parameterName, Time x) throws SQLException {
 792  0
         wrapped.setTime(parameterName, x);
 793  0
         addParam(parameterName, x);
 794   
     }
 795   
 
 796   
     /**
 797   
      * @param parameterName
 798   
      * @param x
 799   
      * @param cal
 800   
      * @throws java.sql.SQLException
 801   
      */
 802  0
     public void setTime(String parameterName, Time x, Calendar cal)
 803   
             throws SQLException {
 804  0
         wrapped.setTime(parameterName, x, cal);
 805  0
         addParam(parameterName, x);
 806   
     }
 807   
 
 808   
     /**
 809   
      * @param parameterName
 810   
      * @param x
 811   
      * @throws java.sql.SQLException
 812   
      */
 813  0
     public void setTimestamp(String parameterName, Timestamp x)
 814   
             throws SQLException {
 815  0
         wrapped.setTimestamp(parameterName, x);
 816  0
         addParam(parameterName, x);
 817   
     }
 818   
 
 819   
     /**
 820   
      * @param parameterName
 821   
      * @param x
 822   
      * @param cal
 823   
      * @throws java.sql.SQLException
 824   
      */
 825  0
     public void setTimestamp(String parameterName, Timestamp x, Calendar cal)
 826   
             throws SQLException {
 827  0
         wrapped.setTimestamp(parameterName, x, cal);
 828  0
         addParam(parameterName, x);
 829   
     }
 830   
 
 831   
     /**
 832   
      * @param parameterName
 833   
      * @param val
 834   
      * @throws java.sql.SQLException
 835   
      */
 836  0
     public void setURL(String parameterName, URL x) throws SQLException {
 837  0
         wrapped.setURL(parameterName, x);
 838  0
         addParam(parameterName, x);
 839   
     }
 840   
 
 841   
     /**
 842   
      * @return @throws
 843   
      *         java.sql.SQLException
 844   
      */
 845  0
     public boolean wasNull() throws SQLException {
 846  0
         return wrapped.wasNull();
 847   
     }
 848   
 
 849   
 }