Clover coverage report - brownies library - 1.0-beta-1
Coverage timestamp: 月 8 16 2004 17:14:42 GMT+09:00
file stats: LOC: 1,289   Methods: 140
NCLOC: 459   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
ResultSetWrapper.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.Clob;
 14   
 import java.sql.Date;
 15   
 import java.sql.Ref;
 16   
 import java.sql.ResultSet;
 17   
 import java.sql.ResultSetMetaData;
 18   
 import java.sql.SQLException;
 19   
 import java.sql.SQLWarning;
 20   
 import java.sql.Statement;
 21   
 import java.sql.Time;
 22   
 import java.sql.Timestamp;
 23   
 import java.util.Calendar;
 24   
 import java.util.Map;
 25   
 
 26   
 import org.asyrinx.brownie.core.util.Wrapper;
 27   
 
 28   
 /**
 29   
  * @author Akima
 30   
  */
 31   
 public class ResultSetWrapper extends Wrapper implements ResultSet {
 32   
 
 33   
     /**
 34   
      * Constructor for ResultSetWrapper.
 35   
      */
 36  0
     public ResultSetWrapper(ResultSet impl) {
 37  0
         super(impl);
 38  0
         this.impl = impl;
 39   
     }
 40   
 
 41   
     protected final ResultSet impl;
 42   
 
 43   
     /**
 44   
      * @param row
 45   
      * @return @throws
 46   
      *         java.sql.SQLException
 47   
      */
 48  0
     public boolean absolute(int row) throws SQLException {
 49  0
         return impl.absolute(row);
 50   
     }
 51   
 
 52   
     /**
 53   
      * @throws java.sql.SQLException
 54   
      */
 55  0
     public void afterLast() throws SQLException {
 56  0
         impl.afterLast();
 57   
     }
 58   
 
 59   
     /**
 60   
      * @throws java.sql.SQLException
 61   
      */
 62  0
     public void beforeFirst() throws SQLException {
 63  0
         impl.beforeFirst();
 64   
     }
 65   
 
 66   
     /**
 67   
      * @throws java.sql.SQLException
 68   
      */
 69  0
     public void cancelRowUpdates() throws SQLException {
 70  0
         impl.cancelRowUpdates();
 71   
     }
 72   
 
 73   
     /**
 74   
      * @throws java.sql.SQLException
 75   
      */
 76  0
     public void clearWarnings() throws SQLException {
 77  0
         impl.clearWarnings();
 78   
     }
 79   
 
 80   
     /**
 81   
      * @throws java.sql.SQLException
 82   
      */
 83  0
     public void close() throws SQLException {
 84  0
         impl.close();
 85   
     }
 86   
 
 87   
     /**
 88   
      * @throws java.sql.SQLException
 89   
      */
 90  0
     public void deleteRow() throws SQLException {
 91  0
         impl.deleteRow();
 92   
     }
 93   
 
 94   
     /**
 95   
      * @param columnName
 96   
      * @return @throws
 97   
      *         java.sql.SQLException
 98   
      */
 99  0
     public int findColumn(String columnName) throws SQLException {
 100  0
         return impl.findColumn(columnName);
 101   
     }
 102   
 
 103   
     /**
 104   
      * @return @throws
 105   
      *         java.sql.SQLException
 106   
      */
 107  0
     public boolean first() throws SQLException {
 108  0
         return impl.first();
 109   
     }
 110   
 
 111   
     /**
 112   
      * @param i
 113   
      * @return @throws
 114   
      *         java.sql.SQLException
 115   
      */
 116  0
     public Array getArray(int i) throws SQLException {
 117  0
         return impl.getArray(i);
 118   
     }
 119   
 
 120   
     /**
 121   
      * @param colName
 122   
      * @return @throws
 123   
      *         java.sql.SQLException
 124   
      */
 125  0
     public Array getArray(String colName) throws SQLException {
 126  0
         return impl.getArray(colName);
 127   
     }
 128   
 
 129   
     /**
 130   
      * @param columnIndex
 131   
      * @return @throws
 132   
      *         java.sql.SQLException
 133   
      */
 134  0
     public InputStream getAsciiStream(int columnIndex) throws SQLException {
 135  0
         return impl.getAsciiStream(columnIndex);
 136   
     }
 137   
 
 138   
     /**
 139   
      * @param columnName
 140   
      * @return @throws
 141   
      *         java.sql.SQLException
 142   
      */
 143  0
     public InputStream getAsciiStream(String columnName) throws SQLException {
 144  0
         return impl.getAsciiStream(columnName);
 145   
     }
 146   
 
 147   
     /**
 148   
      * @param columnIndex
 149   
      * @return @throws
 150   
      *         java.sql.SQLException
 151   
      */
 152  0
     public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
 153  0
         return impl.getBigDecimal(columnIndex);
 154   
     }
 155   
 
 156   
     /**
 157   
      * @param columnIndex
 158   
      * @param scale
 159   
      * @return @throws
 160   
      *         java.sql.SQLException
 161   
      * @deprecated
 162   
      */
 163  0
     public BigDecimal getBigDecimal(int columnIndex, int scale)
 164   
             throws SQLException {
 165   
         //return impl.getBigDecimal(columnIndex, scale);
 166  0
         return null;
 167   
     }
 168   
 
 169   
     /**
 170   
      * @param columnName
 171   
      * @return @throws
 172   
      *         java.sql.SQLException
 173   
      */
 174  0
     public BigDecimal getBigDecimal(String columnName) throws SQLException {
 175  0
         return impl.getBigDecimal(columnName);
 176   
     }
 177   
 
 178   
     /**
 179   
      * @param columnName
 180   
      * @param scale
 181   
      * @return @throws
 182   
      *         java.sql.SQLException
 183   
      * @deprecated
 184   
      */
 185  0
     public BigDecimal getBigDecimal(String columnName, int scale)
 186   
             throws SQLException {
 187  0
         return null;
 188   
         //return impl.getBigDecimal(columnName, scale);
 189   
     }
 190   
 
 191   
     /**
 192   
      * @param columnIndex
 193   
      * @return @throws
 194   
      *         java.sql.SQLException
 195   
      */
 196  0
     public InputStream getBinaryStream(int columnIndex) throws SQLException {
 197  0
         return impl.getBinaryStream(columnIndex);
 198   
     }
 199   
 
 200   
     /**
 201   
      * @param columnName
 202   
      * @return @throws
 203   
      *         java.sql.SQLException
 204   
      */
 205  0
     public InputStream getBinaryStream(String columnName) throws SQLException {
 206  0
         return impl.getBinaryStream(columnName);
 207   
     }
 208   
 
 209   
     /**
 210   
      * @param i
 211   
      * @return @throws
 212   
      *         java.sql.SQLException
 213   
      */
 214  0
     public Blob getBlob(int i) throws SQLException {
 215  0
         return impl.getBlob(i);
 216   
     }
 217   
 
 218   
     /**
 219   
      * @param colName
 220   
      * @return @throws
 221   
      *         java.sql.SQLException
 222   
      */
 223  0
     public Blob getBlob(String colName) throws SQLException {
 224  0
         return impl.getBlob(colName);
 225   
     }
 226   
 
 227   
     /**
 228   
      * @param columnIndex
 229   
      * @return @throws
 230   
      *         java.sql.SQLException
 231   
      */
 232  0
     public boolean getBoolean(int columnIndex) throws SQLException {
 233  0
         return impl.getBoolean(columnIndex);
 234   
     }
 235   
 
 236   
     /**
 237   
      * @param columnName
 238   
      * @return @throws
 239   
      *         java.sql.SQLException
 240   
      */
 241  0
     public boolean getBoolean(String columnName) throws SQLException {
 242  0
         return impl.getBoolean(columnName);
 243   
     }
 244   
 
 245   
     /**
 246   
      * @param columnIndex
 247   
      * @return @throws
 248   
      *         java.sql.SQLException
 249   
      */
 250  0
     public byte getByte(int columnIndex) throws SQLException {
 251  0
         return impl.getByte(columnIndex);
 252   
     }
 253   
 
 254   
     /**
 255   
      * @param columnName
 256   
      * @return @throws
 257   
      *         java.sql.SQLException
 258   
      */
 259  0
     public byte getByte(String columnName) throws SQLException {
 260  0
         return impl.getByte(columnName);
 261   
     }
 262   
 
 263   
     /**
 264   
      * @param columnIndex
 265   
      * @return @throws
 266   
      *         java.sql.SQLException
 267   
      */
 268  0
     public byte[] getBytes(int columnIndex) throws SQLException {
 269  0
         return impl.getBytes(columnIndex);
 270   
     }
 271   
 
 272   
     /**
 273   
      * @param columnName
 274   
      * @return @throws
 275   
      *         java.sql.SQLException
 276   
      */
 277  0
     public byte[] getBytes(String columnName) throws SQLException {
 278  0
         return impl.getBytes(columnName);
 279   
     }
 280   
 
 281   
     /**
 282   
      * @param columnIndex
 283   
      * @return @throws
 284   
      *         java.sql.SQLException
 285   
      */
 286  0
     public Reader getCharacterStream(int columnIndex) throws SQLException {
 287  0
         return impl.getCharacterStream(columnIndex);
 288   
     }
 289   
 
 290   
     /**
 291   
      * @param columnName
 292   
      * @return @throws
 293   
      *         java.sql.SQLException
 294   
      */
 295  0
     public Reader getCharacterStream(String columnName) throws SQLException {
 296  0
         return impl.getCharacterStream(columnName);
 297   
     }
 298   
 
 299   
     /**
 300   
      * @param i
 301   
      * @return @throws
 302   
      *         java.sql.SQLException
 303   
      */
 304  0
     public Clob getClob(int i) throws SQLException {
 305  0
         return impl.getClob(i);
 306   
     }
 307   
 
 308   
     /**
 309   
      * @param colName
 310   
      * @return @throws
 311   
      *         java.sql.SQLException
 312   
      */
 313  0
     public Clob getClob(String colName) throws SQLException {
 314  0
         return impl.getClob(colName);
 315   
     }
 316   
 
 317   
     /**
 318   
      * @return @throws
 319   
      *         java.sql.SQLException
 320   
      */
 321  0
     public int getConcurrency() throws SQLException {
 322  0
         return impl.getConcurrency();
 323   
     }
 324   
 
 325   
     /**
 326   
      * @return @throws
 327   
      *         java.sql.SQLException
 328   
      */
 329  0
     public String getCursorName() throws SQLException {
 330  0
         return impl.getCursorName();
 331   
     }
 332   
 
 333   
     /**
 334   
      * @param columnIndex
 335   
      * @return @throws
 336   
      *         java.sql.SQLException
 337   
      */
 338  0
     public Date getDate(int columnIndex) throws SQLException {
 339  0
         return impl.getDate(columnIndex);
 340   
     }
 341   
 
 342   
     /**
 343   
      * @param columnIndex
 344   
      * @param cal
 345   
      * @return @throws
 346   
      *         java.sql.SQLException
 347   
      */
 348  0
     public Date getDate(int columnIndex, Calendar cal) throws SQLException {
 349  0
         return impl.getDate(columnIndex, cal);
 350   
     }
 351   
 
 352   
     /**
 353   
      * @param columnName
 354   
      * @return @throws
 355   
      *         java.sql.SQLException
 356   
      */
 357  0
     public Date getDate(String columnName) throws SQLException {
 358  0
         return impl.getDate(columnName);
 359   
     }
 360   
 
 361   
     /**
 362   
      * @param columnName
 363   
      * @param cal
 364   
      * @return @throws
 365   
      *         java.sql.SQLException
 366   
      */
 367  0
     public Date getDate(String columnName, Calendar cal) throws SQLException {
 368  0
         return impl.getDate(columnName, cal);
 369   
     }
 370   
 
 371   
     /**
 372   
      * @param columnIndex
 373   
      * @return @throws
 374   
      *         java.sql.SQLException
 375   
      */
 376  0
     public double getDouble(int columnIndex) throws SQLException {
 377  0
         return impl.getDouble(columnIndex);
 378   
     }
 379   
 
 380   
     /**
 381   
      * @param columnName
 382   
      * @return @throws
 383   
      *         java.sql.SQLException
 384   
      */
 385  0
     public double getDouble(String columnName) throws SQLException {
 386  0
         return impl.getDouble(columnName);
 387   
     }
 388   
 
 389   
     /**
 390   
      * @return @throws
 391   
      *         java.sql.SQLException
 392   
      */
 393  0
     public int getFetchDirection() throws SQLException {
 394  0
         return impl.getFetchDirection();
 395   
     }
 396   
 
 397   
     /**
 398   
      * @return @throws
 399   
      *         java.sql.SQLException
 400   
      */
 401  0
     public int getFetchSize() throws SQLException {
 402  0
         return impl.getFetchSize();
 403   
     }
 404   
 
 405   
     /**
 406   
      * @param columnIndex
 407   
      * @return @throws
 408   
      *         java.sql.SQLException
 409   
      */
 410  0
     public float getFloat(int columnIndex) throws SQLException {
 411  0
         return impl.getFloat(columnIndex);
 412   
     }
 413   
 
 414   
     /**
 415   
      * @param columnName
 416   
      * @return @throws
 417   
      *         java.sql.SQLException
 418   
      */
 419  0
     public float getFloat(String columnName) throws SQLException {
 420  0
         return impl.getFloat(columnName);
 421   
     }
 422   
 
 423   
     /**
 424   
      * @param columnIndex
 425   
      * @return @throws
 426   
      *         java.sql.SQLException
 427   
      */
 428  0
     public int getInt(int columnIndex) throws SQLException {
 429  0
         return impl.getInt(columnIndex);
 430   
     }
 431   
 
 432   
     /**
 433   
      * @param columnName
 434   
      * @return @throws
 435   
      *         java.sql.SQLException
 436   
      */
 437  0
     public int getInt(String columnName) throws SQLException {
 438  0
         return impl.getInt(columnName);
 439   
     }
 440   
 
 441   
     /**
 442   
      * @param columnIndex
 443   
      * @return @throws
 444   
      *         java.sql.SQLException
 445   
      */
 446  0
     public long getLong(int columnIndex) throws SQLException {
 447  0
         return impl.getLong(columnIndex);
 448   
     }
 449   
 
 450   
     /**
 451   
      * @param columnName
 452   
      * @return @throws
 453   
      *         java.sql.SQLException
 454   
      */
 455  0
     public long getLong(String columnName) throws SQLException {
 456  0
         return impl.getLong(columnName);
 457   
     }
 458   
 
 459   
     /**
 460   
      * @return @throws
 461   
      *         java.sql.SQLException
 462   
      */
 463  0
     public ResultSetMetaData getMetaData() throws SQLException {
 464  0
         return impl.getMetaData();
 465   
     }
 466   
 
 467   
     /**
 468   
      * @param columnIndex
 469   
      * @return @throws
 470   
      *         java.sql.SQLException
 471   
      */
 472  0
     public Object getObject(int columnIndex) throws SQLException {
 473  0
         return impl.getObject(columnIndex);
 474   
     }
 475   
 
 476   
     /**
 477   
      * @param i
 478   
      * @param map
 479   
      * @return @throws
 480   
      *         java.sql.SQLException
 481   
      */
 482  0
     public Object getObject(int i, Map map) throws SQLException {
 483  0
         return impl.getObject(i, map);
 484   
     }
 485   
 
 486   
     /**
 487   
      * @param columnName
 488   
      * @return @throws
 489   
      *         java.sql.SQLException
 490   
      */
 491  0
     public Object getObject(String columnName) throws SQLException {
 492  0
         return impl.getObject(columnName);
 493   
     }
 494   
 
 495   
     /**
 496   
      * @param colName
 497   
      * @param map
 498   
      * @return @throws
 499   
      *         java.sql.SQLException
 500   
      */
 501  0
     public Object getObject(String colName, Map map) throws SQLException {
 502  0
         return impl.getObject(colName, map);
 503   
     }
 504   
 
 505   
     /**
 506   
      * @param i
 507   
      * @return @throws
 508   
      *         java.sql.SQLException
 509   
      */
 510  0
     public Ref getRef(int i) throws SQLException {
 511  0
         return impl.getRef(i);
 512   
     }
 513   
 
 514   
     /**
 515   
      * @param colName
 516   
      * @return @throws
 517   
      *         java.sql.SQLException
 518   
      */
 519  0
     public Ref getRef(String colName) throws SQLException {
 520  0
         return impl.getRef(colName);
 521   
     }
 522   
 
 523   
     /**
 524   
      * @return @throws
 525   
      *         java.sql.SQLException
 526   
      */
 527  0
     public int getRow() throws SQLException {
 528  0
         return impl.getRow();
 529   
     }
 530   
 
 531   
     /**
 532   
      * @param columnIndex
 533   
      * @return @throws
 534   
      *         java.sql.SQLException
 535   
      */
 536  0
     public short getShort(int columnIndex) throws SQLException {
 537  0
         return impl.getShort(columnIndex);
 538   
     }
 539   
 
 540   
     /**
 541   
      * @param columnName
 542   
      * @return @throws
 543   
      *         java.sql.SQLException
 544   
      */
 545  0
     public short getShort(String columnName) throws SQLException {
 546  0
         return impl.getShort(columnName);
 547   
     }
 548   
 
 549   
     /**
 550   
      * @return @throws
 551   
      *         java.sql.SQLException
 552   
      */
 553  0
     public Statement getStatement() throws SQLException {
 554  0
         return impl.getStatement();
 555   
     }
 556   
 
 557   
     /**
 558   
      * @param columnIndex
 559   
      * @return @throws
 560   
      *         java.sql.SQLException
 561   
      */
 562  0
     public String getString(int columnIndex) throws SQLException {
 563  0
         return impl.getString(columnIndex);
 564   
     }
 565   
 
 566   
     /**
 567   
      * @param columnName
 568   
      * @return @throws
 569   
      *         java.sql.SQLException
 570   
      */
 571  0
     public String getString(String columnName) throws SQLException {
 572  0
         return impl.getString(columnName);
 573   
     }
 574   
 
 575   
     /**
 576   
      * @param columnIndex
 577   
      * @return @throws
 578   
      *         java.sql.SQLException
 579   
      */
 580  0
     public Time getTime(int columnIndex) throws SQLException {
 581  0
         return impl.getTime(columnIndex);
 582   
     }
 583   
 
 584   
     /**
 585   
      * @param columnIndex
 586   
      * @param cal
 587   
      * @return @throws
 588   
      *         java.sql.SQLException
 589   
      */
 590  0
     public Time getTime(int columnIndex, Calendar cal) throws SQLException {
 591  0
         return impl.getTime(columnIndex, cal);
 592   
     }
 593   
 
 594   
     /**
 595   
      * @param columnName
 596   
      * @return @throws
 597   
      *         java.sql.SQLException
 598   
      */
 599  0
     public Time getTime(String columnName) throws SQLException {
 600  0
         return impl.getTime(columnName);
 601   
     }
 602   
 
 603   
     /**
 604   
      * @param columnName
 605   
      * @param cal
 606   
      * @return @throws
 607   
      *         java.sql.SQLException
 608   
      */
 609  0
     public Time getTime(String columnName, Calendar cal) throws SQLException {
 610  0
         return impl.getTime(columnName, cal);
 611   
     }
 612   
 
 613   
     /**
 614   
      * @param columnIndex
 615   
      * @return @throws
 616   
      *         java.sql.SQLException
 617   
      */
 618  0
     public Timestamp getTimestamp(int columnIndex) throws SQLException {
 619  0
         return impl.getTimestamp(columnIndex);
 620   
     }
 621   
 
 622   
     /**
 623   
      * @param columnIndex
 624   
      * @param cal
 625   
      * @return @throws
 626   
      *         java.sql.SQLException
 627   
      */
 628  0
     public Timestamp getTimestamp(int columnIndex, Calendar cal)
 629   
             throws SQLException {
 630  0
         return impl.getTimestamp(columnIndex, cal);
 631   
     }
 632   
 
 633   
     /**
 634   
      * @param columnName
 635   
      * @return @throws
 636   
      *         java.sql.SQLException
 637   
      */
 638  0
     public Timestamp getTimestamp(String columnName) throws SQLException {
 639  0
         return impl.getTimestamp(columnName);
 640   
     }
 641   
 
 642   
     /**
 643   
      * @param columnName
 644   
      * @param cal
 645   
      * @return @throws
 646   
      *         java.sql.SQLException
 647   
      */
 648  0
     public Timestamp getTimestamp(String columnName, Calendar cal)
 649   
             throws SQLException {
 650  0
         return impl.getTimestamp(columnName, cal);
 651   
     }
 652   
 
 653   
     /**
 654   
      * @return @throws
 655   
      *         java.sql.SQLException
 656   
      */
 657  0
     public int getType() throws SQLException {
 658  0
         return impl.getType();
 659   
     }
 660   
 
 661   
     /**
 662   
      * @param columnIndex
 663   
      * @return @throws
 664   
      *         java.sql.SQLException
 665   
      * @deprecated
 666   
      */
 667  0
     public InputStream getUnicodeStream(int columnIndex) throws SQLException {
 668   
         //return impl.getUnicodeStream(columnIndex);
 669  0
         return null;
 670   
     }
 671   
 
 672   
     /**
 673   
      * @param columnName
 674   
      * @return @throws
 675   
      *         java.sql.SQLException
 676   
      * @deprecated
 677   
      */
 678  0
     public InputStream getUnicodeStream(String columnName) throws SQLException {
 679   
         //return impl.getUnicodeStream(columnName);
 680  0
         return null;
 681   
     }
 682   
 
 683   
     /**
 684   
      * @param columnIndex
 685   
      * @return @throws
 686   
      *         java.sql.SQLException
 687   
      */
 688  0
     public URL getURL(int columnIndex) throws SQLException {
 689  0
         return impl.getURL(columnIndex);
 690   
     }
 691   
 
 692   
     /**
 693   
      * @param columnName
 694   
      * @return @throws
 695   
      *         java.sql.SQLException
 696   
      */
 697  0
     public URL getURL(String columnName) throws SQLException {
 698  0
         return impl.getURL(columnName);
 699   
     }
 700   
 
 701   
     /**
 702   
      * @return @throws
 703   
      *         java.sql.SQLException
 704   
      */
 705  0
     public SQLWarning getWarnings() throws SQLException {
 706  0
         return impl.getWarnings();
 707   
     }
 708   
 
 709   
     /**
 710   
      * @throws java.sql.SQLException
 711   
      */
 712  0
     public void insertRow() throws SQLException {
 713  0
         impl.insertRow();
 714   
     }
 715   
 
 716   
     /**
 717   
      * @return @throws
 718   
      *         java.sql.SQLException
 719   
      */
 720  0
     public boolean isAfterLast() throws SQLException {
 721  0
         return impl.isAfterLast();
 722   
     }
 723   
 
 724   
     /**
 725   
      * @return @throws
 726   
      *         java.sql.SQLException
 727   
      */
 728  0
     public boolean isBeforeFirst() throws SQLException {
 729  0
         return impl.isBeforeFirst();
 730   
     }
 731   
 
 732   
     /**
 733   
      * @return @throws
 734   
      *         java.sql.SQLException
 735   
      */
 736  0
     public boolean isFirst() throws SQLException {
 737  0
         return impl.isFirst();
 738   
     }
 739   
 
 740   
     /**
 741   
      * @return @throws
 742   
      *         java.sql.SQLException
 743   
      */
 744  0
     public boolean isLast() throws SQLException {
 745  0
         return impl.isLast();
 746   
     }
 747   
 
 748   
     /**
 749   
      * @return @throws
 750   
      *         java.sql.SQLException
 751   
      */
 752  0
     public boolean last() throws SQLException {
 753  0
         return impl.last();
 754   
     }
 755   
 
 756   
     /**
 757   
      * @throws java.sql.SQLException
 758   
      */
 759  0
     public void moveToCurrentRow() throws SQLException {
 760  0
         impl.moveToCurrentRow();
 761   
     }
 762   
 
 763   
     /**
 764   
      * @throws java.sql.SQLException
 765   
      */
 766  0
     public void moveToInsertRow() throws SQLException {
 767  0
         impl.moveToInsertRow();
 768   
     }
 769   
 
 770   
     /**
 771   
      * @return @throws
 772   
      *         java.sql.SQLException
 773   
      */
 774  0
     public boolean next() throws SQLException {
 775  0
         return impl.next();
 776   
     }
 777   
 
 778   
     /**
 779   
      * @return @throws
 780   
      *         java.sql.SQLException
 781   
      */
 782  0
     public boolean previous() throws SQLException {
 783  0
         return impl.previous();
 784   
     }
 785   
 
 786   
     /**
 787   
      * @throws java.sql.SQLException
 788   
      */
 789  0
     public void refreshRow() throws SQLException {
 790  0
         impl.refreshRow();
 791   
     }
 792   
 
 793   
     /**
 794   
      * @param rows
 795   
      * @return @throws
 796   
      *         java.sql.SQLException
 797   
      */
 798  0
     public boolean relative(int rows) throws SQLException {
 799  0
         return impl.relative(rows);
 800   
     }
 801   
 
 802   
     /**
 803   
      * @return @throws
 804   
      *         java.sql.SQLException
 805   
      */
 806  0
     public boolean rowDeleted() throws SQLException {
 807  0
         return impl.rowDeleted();
 808   
     }
 809   
 
 810   
     /**
 811   
      * @return @throws
 812   
      *         java.sql.SQLException
 813   
      */
 814  0
     public boolean rowInserted() throws SQLException {
 815  0
         return impl.rowInserted();
 816   
     }
 817   
 
 818   
     /**
 819   
      * @return @throws
 820   
      *         java.sql.SQLException
 821   
      */
 822  0
     public boolean rowUpdated() throws SQLException {
 823  0
         return impl.rowUpdated();
 824   
     }
 825   
 
 826   
     /**
 827   
      * @param direction
 828   
      * @throws java.sql.SQLException
 829   
      */
 830  0
     public void setFetchDirection(int direction) throws SQLException {
 831  0
         impl.setFetchDirection(direction);
 832   
     }
 833   
 
 834   
     /**
 835   
      * @param rows
 836   
      * @throws java.sql.SQLException
 837   
      */
 838  0
     public void setFetchSize(int rows) throws SQLException {
 839  0
         impl.setFetchSize(rows);
 840   
     }
 841   
 
 842   
     /**
 843   
      * @param columnIndex
 844   
      * @param x
 845   
      * @throws java.sql.SQLException
 846   
      */
 847  0
     public void updateArray(int columnIndex, Array x) throws SQLException {
 848  0
         impl.updateArray(columnIndex, x);
 849   
     }
 850   
 
 851   
     /**
 852   
      * @param columnName
 853   
      * @param x
 854   
      * @throws java.sql.SQLException
 855   
      */
 856  0
     public void updateArray(String columnName, Array x) throws SQLException {
 857  0
         impl.updateArray(columnName, x);
 858   
     }
 859   
 
 860   
     /**
 861   
      * @param columnIndex
 862   
      * @param x
 863   
      * @param length
 864   
      * @throws java.sql.SQLException
 865   
      */
 866  0
     public void updateAsciiStream(int columnIndex, InputStream x, int length)
 867   
             throws SQLException {
 868  0
         impl.updateAsciiStream(columnIndex, x, length);
 869   
     }
 870   
 
 871   
     /**
 872   
      * @param columnName
 873   
      * @param x
 874   
      * @param length
 875   
      * @throws java.sql.SQLException
 876   
      */
 877  0
     public void updateAsciiStream(String columnName, InputStream x, int length)
 878   
             throws SQLException {
 879  0
         impl.updateAsciiStream(columnName, x, length);
 880   
     }
 881   
 
 882   
     /**
 883   
      * @param columnIndex
 884   
      * @param x
 885   
      * @throws java.sql.SQLException
 886   
      */
 887  0
     public void updateBigDecimal(int columnIndex, BigDecimal x)
 888   
             throws SQLException {
 889  0
         impl.updateBigDecimal(columnIndex, x);
 890   
     }
 891   
 
 892   
     /**
 893   
      * @param columnName
 894   
      * @param x
 895   
      * @throws java.sql.SQLException
 896   
      */
 897  0
     public void updateBigDecimal(String columnName, BigDecimal x)
 898   
             throws SQLException {
 899  0
         impl.updateBigDecimal(columnName, x);
 900   
     }
 901   
 
 902   
     /**
 903   
      * @param columnIndex
 904   
      * @param x
 905   
      * @param length
 906   
      * @throws java.sql.SQLException
 907   
      */
 908  0
     public void updateBinaryStream(int columnIndex, InputStream x, int length)
 909   
             throws SQLException {
 910  0
         impl.updateBinaryStream(columnIndex, x, length);
 911   
     }
 912   
 
 913   
     /**
 914   
      * @param columnName
 915   
      * @param x
 916   
      * @param length
 917   
      * @throws java.sql.SQLException
 918   
      */
 919  0
     public void updateBinaryStream(String columnName, InputStream x, int length)
 920   
             throws SQLException {
 921  0
         impl.updateBinaryStream(columnName, x, length);
 922   
     }
 923   
 
 924   
     /**
 925   
      * @param columnIndex
 926   
      * @param x
 927   
      * @throws java.sql.SQLException
 928   
      */
 929  0
     public void updateBlob(int columnIndex, Blob x) throws SQLException {
 930  0
         impl.updateBlob(columnIndex, x);
 931   
     }
 932   
 
 933   
     /**
 934   
      * @param columnName
 935   
      * @param x
 936   
      * @throws java.sql.SQLException
 937   
      */
 938  0
     public void updateBlob(String columnName, Blob x) throws SQLException {
 939  0
         impl.updateBlob(columnName, x);
 940   
     }
 941   
 
 942   
     /**
 943   
      * @param columnIndex
 944   
      * @param x
 945   
      * @throws java.sql.SQLException
 946   
      */
 947  0
     public void updateBoolean(int columnIndex, boolean x) throws SQLException {
 948  0
         impl.updateBoolean(columnIndex, x);
 949   
     }
 950   
 
 951   
     /**
 952   
      * @param columnName
 953   
      * @param x
 954   
      * @throws java.sql.SQLException
 955   
      */
 956  0
     public void updateBoolean(String columnName, boolean x) throws SQLException {
 957  0
         impl.updateBoolean(columnName, x);
 958   
     }
 959   
 
 960   
     /**
 961   
      * @param columnIndex
 962   
      * @param x
 963   
      * @throws java.sql.SQLException
 964   
      */
 965  0
     public void updateByte(int columnIndex, byte x) throws SQLException {
 966  0
         impl.updateByte(columnIndex, x);
 967   
     }
 968   
 
 969   
     /**
 970   
      * @param columnName
 971   
      * @param x
 972   
      * @throws java.sql.SQLException
 973   
      */
 974  0
     public void updateByte(String columnName, byte x) throws SQLException {
 975  0
         impl.updateByte(columnName, x);
 976   
     }
 977   
 
 978   
     /**
 979   
      * @param columnIndex
 980   
      * @param x
 981   
      * @throws java.sql.SQLException
 982   
      */
 983  0
     public void updateBytes(int columnIndex, byte[] x) throws SQLException {
 984  0
         impl.updateBytes(columnIndex, x);
 985   
     }
 986   
 
 987   
     /**
 988   
      * @param columnName
 989   
      * @param x
 990   
      * @throws java.sql.SQLException
 991   
      */
 992  0
     public void updateBytes(String columnName, byte[] x) throws SQLException {
 993  0
         impl.updateBytes(columnName, x);
 994   
     }
 995   
 
 996   
     /**
 997   
      * @param columnIndex
 998   
      * @param x
 999   
      * @param length
 1000   
      * @throws java.sql.SQLException
 1001   
      */
 1002  0
     public void updateCharacterStream(int columnIndex, Reader x, int length)
 1003   
             throws SQLException {
 1004  0
         impl.updateCharacterStream(columnIndex, x, length);
 1005   
     }
 1006   
 
 1007   
     /**
 1008   
      * @param columnName
 1009   
      * @param reader
 1010   
      * @param length
 1011   
      * @throws java.sql.SQLException
 1012   
      */
 1013  0
     public void updateCharacterStream(String columnName, Reader reader,
 1014   
             int length) throws SQLException {
 1015  0
         impl.updateCharacterStream(columnName, reader, length);
 1016   
     }
 1017   
 
 1018   
     /**
 1019   
      * @param columnIndex
 1020   
      * @param x
 1021   
      * @throws java.sql.SQLException
 1022   
      */
 1023  0
     public void updateClob(int columnIndex, Clob x) throws SQLException {
 1024  0
         impl.updateClob(columnIndex, x);
 1025   
     }
 1026   
 
 1027   
     /**
 1028   
      * @param columnName
 1029   
      * @param x
 1030   
      * @throws java.sql.SQLException
 1031   
      */
 1032  0
     public void updateClob(String columnName, Clob x) throws SQLException {
 1033  0
         impl.updateClob(columnName, x);
 1034   
     }
 1035   
 
 1036   
     /**
 1037   
      * @param columnIndex
 1038   
      * @param x
 1039   
      * @throws java.sql.SQLException
 1040   
      */
 1041  0
     public void updateDate(int columnIndex, Date x) throws SQLException {
 1042  0
         impl.updateDate(columnIndex, x);
 1043   
     }
 1044   
 
 1045   
     /**
 1046   
      * @param columnName
 1047   
      * @param x
 1048   
      * @throws java.sql.SQLException
 1049   
      */
 1050  0
     public void updateDate(String columnName, Date x) throws SQLException {
 1051  0
         impl.updateDate(columnName, x);
 1052   
     }
 1053   
 
 1054   
     /**
 1055   
      * @param columnIndex
 1056   
      * @param x
 1057   
      * @throws java.sql.SQLException
 1058   
      */
 1059  0
     public void updateDouble(int columnIndex, double x) throws SQLException {
 1060  0
         impl.updateDouble(columnIndex, x);
 1061   
     }
 1062   
 
 1063   
     /**
 1064   
      * @param columnName
 1065   
      * @param x
 1066   
      * @throws java.sql.SQLException
 1067   
      */
 1068  0
     public void updateDouble(String columnName, double x) throws SQLException {
 1069  0
         impl.updateDouble(columnName, x);
 1070   
     }
 1071   
 
 1072   
     /**
 1073   
      * @param columnIndex
 1074   
      * @param x
 1075   
      * @throws java.sql.SQLException
 1076   
      */
 1077  0
     public void updateFloat(int columnIndex, float x) throws SQLException {
 1078  0
         impl.updateFloat(columnIndex, x);
 1079   
     }
 1080   
 
 1081   
     /**
 1082   
      * @param columnName
 1083   
      * @param x
 1084   
      * @throws java.sql.SQLException
 1085   
      */
 1086  0
     public void updateFloat(String columnName, float x) throws SQLException {
 1087  0
         impl.updateFloat(columnName, x);
 1088   
     }
 1089   
 
 1090   
     /**
 1091   
      * @param columnIndex
 1092   
      * @param x
 1093   
      * @throws java.sql.SQLException
 1094   
      */
 1095  0
     public void updateInt(int columnIndex, int x) throws SQLException {
 1096  0
         impl.updateInt(columnIndex, x);
 1097   
     }
 1098   
 
 1099   
     /**
 1100   
      * @param columnName
 1101   
      * @param x
 1102   
      * @throws java.sql.SQLException
 1103   
      */
 1104  0
     public void updateInt(String columnName, int x) throws SQLException {
 1105  0
         impl.updateInt(columnName, x);
 1106   
     }
 1107   
 
 1108   
     /**
 1109   
      * @param columnIndex
 1110   
      * @param x
 1111   
      * @throws java.sql.SQLException
 1112   
      */
 1113  0
     public void updateLong(int columnIndex, long x) throws SQLException {
 1114  0
         impl.updateLong(columnIndex, x);
 1115   
     }
 1116   
 
 1117   
     /**
 1118   
      * @param columnName
 1119   
      * @param x
 1120   
      * @throws java.sql.SQLException
 1121   
      */
 1122  0
     public void updateLong(String columnName, long x) throws SQLException {
 1123  0
         impl.updateLong(columnName, x);
 1124   
     }
 1125   
 
 1126   
     /**
 1127   
      * @param columnIndex
 1128   
      * @throws java.sql.SQLException
 1129   
      */
 1130  0
     public void updateNull(int columnIndex) throws SQLException {
 1131  0
         impl.updateNull(columnIndex);
 1132   
     }
 1133   
 
 1134   
     /**
 1135   
      * @param columnName
 1136   
      * @throws java.sql.SQLException
 1137   
      */
 1138  0
     public void updateNull(String columnName) throws SQLException {
 1139  0
         impl.updateNull(columnName);
 1140   
     }
 1141   
 
 1142   
     /**
 1143   
      * @param columnIndex
 1144   
      * @param x
 1145   
      * @throws java.sql.SQLException
 1146   
      */
 1147  0
     public void updateObject(int columnIndex, Object x) throws SQLException {
 1148  0
         impl.updateObject(columnIndex, x);
 1149   
     }
 1150   
 
 1151   
     /**
 1152   
      * @param columnIndex
 1153   
      * @param x
 1154   
      * @param scale
 1155   
      * @throws java.sql.SQLException
 1156   
      */
 1157  0
     public void updateObject(int columnIndex, Object x, int scale)
 1158   
             throws SQLException {
 1159  0
         impl.updateObject(columnIndex, x, scale);
 1160   
     }
 1161   
 
 1162   
     /**
 1163   
      * @param columnName
 1164   
      * @param x
 1165   
      * @throws java.sql.SQLException
 1166   
      */
 1167  0
     public void updateObject(String columnName, Object x) throws SQLException {
 1168  0
         impl.updateObject(columnName, x);
 1169   
     }
 1170   
 
 1171   
     /**
 1172   
      * @param columnName
 1173   
      * @param x
 1174   
      * @param scale
 1175   
      * @throws java.sql.SQLException
 1176   
      */
 1177  0
     public void updateObject(String columnName, Object x, int scale)
 1178   
             throws SQLException {
 1179  0
         impl.updateObject(columnName, x, scale);
 1180   
     }
 1181   
 
 1182   
     /**
 1183   
      * @param columnIndex
 1184   
      * @param x
 1185   
      * @throws java.sql.SQLException
 1186   
      */
 1187  0
     public void updateRef(int columnIndex, Ref x) throws SQLException {
 1188  0
         impl.updateRef(columnIndex, x);
 1189   
     }
 1190   
 
 1191   
     /**
 1192   
      * @param columnName
 1193   
      * @param x
 1194   
      * @throws java.sql.SQLException
 1195   
      */
 1196  0
     public void updateRef(String columnName, Ref x) throws SQLException {
 1197  0
         impl.updateRef(columnName, x);
 1198   
     }
 1199   
 
 1200   
     /**
 1201   
      * @throws java.sql.SQLException
 1202   
      */
 1203  0
     public void updateRow() throws SQLException {
 1204  0
         impl.updateRow();
 1205   
     }
 1206   
 
 1207   
     /**
 1208   
      * @param columnIndex
 1209   
      * @param x
 1210   
      * @throws java.sql.SQLException
 1211   
      */
 1212  0
     public void updateShort(int columnIndex, short x) throws SQLException {
 1213  0
         impl.updateShort(columnIndex, x);
 1214   
     }
 1215   
 
 1216   
     /**
 1217   
      * @param columnName
 1218   
      * @param x
 1219   
      * @throws java.sql.SQLException
 1220   
      */
 1221  0
     public void updateShort(String columnName, short x) throws SQLException {
 1222  0
         impl.updateShort(columnName, x);
 1223   
     }
 1224   
 
 1225   
     /**
 1226   
      * @param columnIndex
 1227   
      * @param x
 1228   
      * @throws java.sql.SQLException
 1229   
      */
 1230  0
     public void updateString(int columnIndex, String x) throws SQLException {
 1231  0
         impl.updateString(columnIndex, x);
 1232   
     }
 1233   
 
 1234   
     /**
 1235   
      * @param columnName
 1236   
      * @param x
 1237   
      * @throws java.sql.SQLException
 1238   
      */
 1239  0
     public void updateString(String columnName, String x) throws SQLException {
 1240  0
         impl.updateString(columnName, x);
 1241   
     }
 1242   
 
 1243   
     /**
 1244   
      * @param columnIndex
 1245   
      * @param x
 1246   
      * @throws java.sql.SQLException
 1247   
      */
 1248  0
     public void updateTime(int columnIndex, Time x) throws SQLException {
 1249  0
         impl.updateTime(columnIndex, x);
 1250   
     }
 1251   
 
 1252   
     /**
 1253   
      * @param columnName
 1254   
      * @param x
 1255   
      * @throws java.sql.SQLException
 1256   
      */
 1257  0
     public void updateTime(String columnName, Time x) throws SQLException {
 1258  0
         impl.updateTime(columnName, x);
 1259   
     }
 1260   
 
 1261   
     /**
 1262   
      * @param columnIndex
 1263   
      * @param x
 1264   
      * @throws java.sql.SQLException
 1265   
      */
 1266  0
     public void updateTimestamp(int columnIndex, Timestamp x)
 1267   
             throws SQLException {
 1268  0
         impl.updateTimestamp(columnIndex, x);
 1269   
     }
 1270   
 
 1271   
     /**
 1272   
      * @param columnName
 1273   
      * @param x
 1274   
      * @throws java.sql.SQLException
 1275   
      */
 1276  0
     public void updateTimestamp(String columnName, Timestamp x)
 1277   
             throws SQLException {
 1278  0
         impl.updateTimestamp(columnName, x);
 1279   
     }
 1280   
 
 1281   
     /**
 1282   
      * @return @throws
 1283   
      *         java.sql.SQLException
 1284   
      */
 1285  0
     public boolean wasNull() throws SQLException {
 1286  0
         return impl.wasNull();
 1287   
     }
 1288   
 
 1289   
 }