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