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