开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > WEB源码(ASP,PHP,...) > 查看源码
PageableResultSet2.java
资源名称：GamVanClub.rar　[点击查看]
上传用户：u_thks
上传日期：2022-07-31
资源大小：1910k
文件大小：29k
源码类别：

WEB源码(ASP,PHP,...)

开发平台：

Java

PageableResultSet2.java：源码内容
  1. package com.gamvan.sql;
  2. import java.sql.*;
  3. public class PageableResultSet2 implements Pageable {
  4.     protected java.sql.ResultSet rs=null;
  5.     protected int rowsCount;
  6.     protected int pageSize ;
  7.     protected int curPage;
  8.     protected String command = "" ;
  9.     public PageableResultSet2(java.sql.ResultSet rs) throws java.sql.SQLException {
  10.         if(rs==null) throw new SQLException("given ResultSet is NULL","user");
  11.         rs.last();
  12.         rowsCount=rs.getRow();
  13.         rs.beforeFirst();
  14.         this.rs=rs;
  15.     }
  16.     public PageableResultSet2(java.sql.ResultSet rs, String command) throws java.sql.SQLException {
  17.             if(rs==null) throw new SQLException("given ResultSet is NULL","user");
  18.             rs.last();
  19.             rowsCount=rs.getRow();
  20.             rs.beforeFirst();
  21.             this.rs=rs;
  22.             this.command = command;
  23.     }
  24.     public int getCurPage() {
  25.         return curPage;
  26.     }
  27.     //////////////////////////
  28.     public java.net.URL getURL(String columnName) throws SQLException{
  29.         return rs.getURL(columnName);
  30.     }
  31.     public java.net.URL getURL(int columnName) throws SQLException{
  32.         return rs.getURL(columnName);
  33.     }
  34.     /////////////////////////////////
  35.     public int getPageCount() {
  36.         if(rowsCount==0) return 0;
  37.         if(pageSize==0) return 1;
  38.         //calculate PageCount
  39.         double tmpD=(double)rowsCount/pageSize;
  40.         int tmpI=(int)tmpD;
  41.         if(tmpD>tmpI) tmpI++;
  42.         return tmpI;
  43.     }
  44.     public int getPageRowsCount() {
  45.         if(pageSize==0) return rowsCount;
  46.         if(getRowsCount()==0) return 0;
  47.         if(curPage!=getPageCount()) return pageSize;
  48.         return rowsCount-(getPageCount()-1)*pageSize;
  49.     }
  50.     public int getPageSize() {
  51.         return pageSize;
  52.     }
  53.     public int getRowsCount() {
  54.         return rowsCount;
  55.     }
  56.     public void gotoPage(int page) {
  57.         if (rs == null)
  58.             return;
  59.         if (page < 1)
  60.             page = 1;
  61.         if (page > getPageCount())
  62.             page = getPageCount();
  63.         int row = (page - 1) * pageSize + 1;
  64.         try {
  65.             rs.absolute(row);
  66.             curPage = page;
  67.         }
  68.         catch (java.sql.SQLException e) {
  69.         }
  70.     }
  71.     public void pageFirst() throws java.sql.SQLException {
  72.         int row=(curPage-1)*pageSize+1;
  73.         rs.absolute(row);
  74.     }
  75.     public void pageLast() throws java.sql.SQLException {
  76.         int row=(curPage-1)*pageSize+getPageRowsCount();
  77.         rs.absolute(row);
  78.     }
  79.     public void setPageSize(int pageSize) {
  80.         if(pageSize>=0){
  81.             this.pageSize=pageSize;
  82.             curPage=1;
  83.         }
  84.     }  
  85. //============================================================================
  86.     public boolean absolute(int row) throws SQLException {
  87.             return rs.absolute(row);
  88.     }
  89.     public void afterLast() throws SQLException {
  90.             rs.afterLast();
  91.     }
  92.     public void beforeFirst() throws SQLException {
  93.             rs.beforeFirst();
  94.     }
  95.     public void cancelRowUpdates() throws SQLException {
  96.             rs.cancelRowUpdates();
  97.     }
  98.     public void clearWarnings() throws SQLException {
  99.             rs.clearWarnings();
  100.     }
  101.     public void close() throws SQLException {
  102.             rs.close();
  103.     }
  104.     public void deleteRow() throws SQLException {
  105.             rs.deleteRow();
  106.     }
  107.     public int findColumn(String columnName) throws SQLException { try
  108.             {
  109.                     return rs.findColumn(columnName);
  110.             }
  111.             catch (SQLException e)
  112.             {
  113.                     throw new SQLException(e.toString()+ "/"+columnName + "/"+this.getCommand());
  114.             }
  115.     }
  116.     public boolean first() throws SQLException {
  117.             return rs.first();
  118.     }
  119.     public Array getArray(int i) throws SQLException {
  120.             try
  121.             {
  122.                     return rs.getArray(i);
  123.             }
  124.             catch (SQLException e)
  125.             {
  126.                     throw new SQLException (e.getMessage()+" column Index="+i
  127.                             +"rnSQL="+this.getCommand());
  128.             }
  129.     }
  130.     public Array getArray(String colName) throws SQLException {
  131. try
  132. {
  133. return rs.getArray(colName);
  134. }
  135. catch (SQLException e)
  136. {
  137. throw new SQLException (e.getMessage()+" columnName="+colName
  138. +"rnSQL="+this.getCommand());
  139. }
  140. }
  141.     public java.io.InputStream getAsciiStream(int columnIndex) throws SQLException {
  142. try
  143. {
  144. return rs.getAsciiStream(columnIndex);
  145. }
  146. catch (SQLException e)
  147. {
  148. throw new SQLException (e.getMessage()+" column Index="+columnIndex
  149. +"rnSQL="+this.getCommand());
  150. }
  151. }
  152.     public java.io.InputStream getAsciiStream(String columnName) throws SQLException{
  153. try
  154. {
  155. return rs.getAsciiStream(columnName);
  156. }
  157. catch (SQLException e)
  158. {
  159. throw new SQLException (e.getMessage()+" columnName="+columnName
  160. +"rnSQL="+this.getCommand());
  161. }
  162. }
  163.     public java.math.BigDecimal getBigDecimal(int columnIndex) throws SQLException {
  164. try
  165. {
  166. return rs.getBigDecimal(columnIndex);
  167. }
  168. catch (SQLException e)
  169. {
  170. throw new SQLException (e.getMessage()+" column Index="+columnIndex
  171. +"rnSQL="+this.getCommand());
  172. }
  174. }
  175.     public java.math.BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
  176. throw new SQLException("Deprecated Method, Don't Call it!","user");
  177. }
  178.     public java.math.BigDecimal getBigDecimal(String columnName) throws SQLException {
  179. try
  180. {
  181. return rs.getBigDecimal(columnName);
  182. }
  183. catch (SQLException e)
  184. {
  185. throw new SQLException (e.getMessage()+" columnName="+columnName
  186. +"rnSQL="+this.getCommand());
  187. }
  188. }
  189.     public java.math.BigDecimal getBigDecimal(String columnName, int scale) throws SQLException {
  190.             throw new SQLException("Deprecated Method, Don't Call it!","user");
  191.     }
  192.     public java.io.InputStream getBinaryStream(int columnIndex) throws SQLException{
  193. try
  194. {
  195. return rs.getBinaryStream(columnIndex);
  196. }
  197. catch (SQLException e)
  198. {
  199. throw new SQLException (e.getMessage()+" column Index="+columnIndex
  200. +"rnSQL="+this.getCommand());
  201. }
  202. }
  203.     public java.io.InputStream getBinaryStream(String columnName) throws SQLException {
  204. try
  205. {
  206. return rs.getBinaryStream(columnName);
  207. }
  208. catch (SQLException e)
  209. {
  210. throw new SQLException (e.getMessage()+" columnName="+columnName
  211. +"rnSQL="+this.getCommand());
  212. }
  214. }
  215.     public Blob getBlob(int columnIndex) throws SQLException {
  216. try
  217. {
  218. return rs.getBlob(columnIndex);
  219. }
  220. catch (SQLException e)
  221. {
  222. throw new SQLException (e.getMessage()+" column Index="+columnIndex
  223. +"rnSQL="+this.getCommand());
  224. }
  225. }
  226.     public Blob getBlob(String colName) throws SQLException{
  227. try
  228. {
  229. return rs.getBlob(colName);
  230. }
  231. catch (SQLException e)
  232. {
  233. throw new SQLException (e.getMessage()+" columnName="+colName
  234. +"rnSQL="+this.getCommand());
  235. }
  236. }
  237.     public boolean getBoolean(int columnIndex) throws SQLException {
  238.             try
  239.             {
  240.                     return rs.getBoolean(columnIndex);
  241.             }
  242.             catch (SQLException e)
  243.             {
  244.                     throw new SQLException (e.getMessage()+" column Index="+columnIndex
  245.                             +"rnSQL="+this.getCommand());
  246.             }
  247.     }
  248.     public boolean getBoolean(String columnName) throws SQLException {
  249. try
  250. {
  251. return rs.getBoolean(columnName);
  252. }
  253. catch (SQLException e)
  254. {
  255. throw new SQLException (e.getMessage()+" columnName="+columnName
  256. +"rnSQL="+this.getCommand());
  257. }
  258. }
  259.     public byte getByte(int columnIndex) throws SQLException {
  260. try
  261. {
  262. return rs.getByte(columnIndex);
  263. }
  264. catch (SQLException e)
  265. {
  266. throw new SQLException (e.getMessage()+" column Index="+columnIndex
  267. +"rnSQL="+this.getCommand());
  268. }
  269. }
  270.     public byte getByte(String columnName) throws SQLException{
  271. try
  272. {
  273. return rs.getByte(columnName);
  274. }
  275. catch (SQLException e)
  276. {
  277. throw new SQLException (e.getMessage()+" columnName="+columnName
  278. +"rnSQL="+this.getCommand());
  279. }
  280. }
  281.     public byte[] getBytes(int columnIndex) throws SQLException {
  282. try
  283. {
  284. return rs.getBytes(columnIndex);
  285. }
  286. catch (SQLException e)
  287. {
  288. throw new SQLException (e.getMessage()+" column Index="+columnIndex
  289. +"rnSQL="+this.getCommand());
  290. }
  291. }
  292.     public byte[] getBytes(String columnName) throws SQLException{
  293. try
  294. {
  295. return rs.getBytes(columnName);
  296. }
  297. catch (SQLException e)
  298. {
  299. throw new SQLException (e.getMessage()+" columnName="+columnName
  300. +"rnSQL="+this.getCommand());
  301. }
  303. }
  304.     public java.io.Reader getCharacterStream(int columnIndex) throws SQLException {
  305. try
  306. {
  307. return rs.getCharacterStream(columnIndex);
  308. }
  309. catch (SQLException e)
  310. {
  311. throw new SQLException (e.getMessage()+" column Index="+columnIndex
  312. +"rnSQL="+this.getCommand());
  313. }
  314. }
  315.     public java.io.Reader getCharacterStream(String columnName) throws SQLException {
  316.             try
  317.             {
  318.                     return rs.getCharacterStream(columnName);
  319.             }
  320.             catch (SQLException e)
  321.             {
  322.                     throw new SQLException (e.getMessage()+" columnName="+columnName
  323.                             +"rnSQL="+this.getCommand());
  324.             }
  325.     }
  326.     public Clob getClob(int i) throws SQLException {
  327.             try
  328.             {
  329.                     return rs.getClob(i);
  330.             }
  332.             catch (SQLException e)
  333.             {
  334.                     throw new SQLException (e.getMessage()+" column Index="+i
  335.                             +"rnSQL="+this.getCommand());
  336.             }
  337.     }
  338.     public Clob getClob(String colName) throws SQLException{
  339.             try
  340.             {
  341.                     return rs.getClob(colName);
  342.             }
  343.             catch (SQLException e)
  344.             {
  345.                     throw new SQLException (e.getMessage()+" columnName="+colName
  346.                             +"rnSQL="+this.getCommand());
  347.             }
  348.     }
  349.     public java.lang.String getCommand() {
  350.             return command;
  351.     }
  352.     public int getConcurrency() throws SQLException {
  353.             return rs.getConcurrency();
  354.     }
  356.     public String getCursorName() throws SQLException {
  357.             return rs.getCursorName();
  358.     }
  359.     public Date getDate(int columnIndex) throws SQLException{
  360.             try
  361.             {
  362.                     return rs.getDate(columnIndex);
  363.             }
  364.             catch (SQLException e)
  365.             {
  366.                     throw new SQLException (e.getMessage()+" column Index="+columnIndex
  367.                             +"rnSQL="+this.getCommand());
  368.             }
  369.     }
  370.     public Date getDate(int columnIndex, java.util.Calendar cal) throws SQLException{
  371.             try
  372.             {
  373.                     return rs.getDate(columnIndex,cal);
  374.             }
  375.             catch (SQLException e)
  376.             {
  377.                     throw new SQLException (e.getMessage()+" column Index="+columnIndex
  378.                             +"rnSQL="+this.getCommand());
  379.             }
  380.     }
  381.     public Date getDate(String columnName) throws SQLException{
  382.             try
  383.             {
  384.                     return rs.getDate(columnName);
  385.             }
  386.             catch (SQLException e)
  387.             {
  388.                     throw new SQLException (e.getMessage()+" columnName="+columnName
  389.                             +"rnSQL="+this.getCommand());
  390.             }
  391.     }
  392.     public Date getDate(String columnName, java.util.Calendar cal) throws SQLException {
  393.             try
  394.             {
  395.                     return rs.getDate(columnName,cal);
  396.             }
  397.             catch (SQLException e)
  398.             {
  399.                     throw new SQLException (e.getMessage()+" columnName="+columnName
  400.                             +"rnSQL="+this.getCommand());
  401.             }
  402.     }
  403.     public double getDouble(int columnIndex) throws SQLException {
  404.             try
  405.             {
  406.                     return rs.getDouble(columnIndex);
  407.             }
  408.             catch (SQLException e)
  409.             {
  410.                     throw new SQLException (e.getMessage()+" column Index="+columnIndex
  411.                             +"rnSQL="+this.getCommand());
  412.             }
  413.     }
  414.     public double getDouble(String columnName) throws SQLException {
  415.             try
  416.             {
  417.                     return rs.getDouble(columnName);
  418.             }
  419.             catch (SQLException e)
  420.             {
  421.                     throw new SQLException (e.getMessage()+" columnName="+columnName
  422.                             +"rnSQL="+this.getCommand());
  423.             }
  424.     }
  425.     public int getFetchDirection() throws SQLException {
  426.             return rs.getFetchDirection();
  427.     }
  428.     public int getFetchSize() throws SQLException {
  429.             return rs.getFetchSize();
  430.     }
  431.     public float getFloat(int columnIndex) throws SQLException{
  432.             try
  433.             {
  434.                     return rs.getFloat(columnIndex);
  435.             }
  436.             catch (SQLException e)
  437.             {
  438.                     throw new SQLException (e.getMessage()+" column Index="+columnIndex
  439.                             +"rnSQL="+this.getCommand());
  440.             }
  441.     }
  442.     public float getFloat(String columnName) throws SQLException {
  443. try
  444. {
  445. return rs.getFloat(columnName);
  446. }
  447. catch (SQLException e)
  448. {
  449. throw new SQLException (e.getMessage()+" columnName="+columnName
  450. +"rnSQL="+this.getCommand());
  451. }
  452. }
  453.     public int getInt(int columnIndex) throws SQLException {
  454.             try
  455.             {
  456.                     return rs.getInt(columnIndex);
  457.             }
  458.             catch (SQLException e)
  459.             {
  460.                     throw new SQLException (e.getMessage()+" column Index="+columnIndex
  461.                             +"rnSQL="+this.getCommand());
  462.             }
  464.     }
  465.     public int getInt(String columnName) throws SQLException {
  466.             try
  467.             {
  468.                     return rs.getInt(columnName);
  469.             }
  470.             catch (SQLException e)
  471.             {
  472.                     throw new SQLException (e.getMessage()+" columnName="+columnName
  473.                             +"rnSQL="+this.getCommand());
  474.             }
  475.     }
  476.     public long getLong(int columnIndex) throws SQLException{
  477.             try
  478.             {
  479.                     return rs.getLong(columnIndex);
  480.             }
  481.             catch (SQLException e)
  482.             {
  483.                     throw new SQLException (e.getMessage()+" column Index="+columnIndex
  484.                             +"rnSQL="+this.getCommand());
  485.             }
  487.     }
  488.     public long getLong(String columnName) throws SQLException {
  489. try
  490. {
  491. return rs.getLong(columnName);
  492. }
  493. catch (SQLException e)
  494. {
  495. throw new SQLException (e.getMessage()+" columnName="+columnName
  496. +"rnSQL="+this.getCommand());
  497. }
  498. }
  499.     public ResultSetMetaData getMetaData() throws SQLException {
  500.             return rs.getMetaData();
  501.     }
  502.     public Object getObject(int columnIndex) throws SQLException{
  503.             try
  504.             {
  505.                     return rs.getObject(columnIndex);
  506.             }
  507.             catch (SQLException e)
  508.             {
  509.                     throw new SQLException (e.getMessage()+" column Index="+columnIndex
  510.                             +"rnSQL="+this.getCommand());
  511.             }
  512.     }
  513.     public Object getObject(int i, java.util.Map map) throws SQLException{
  514.             try
  515.             {
  516.                     return rs.getObject(i,map);
  517.             }
  518.             catch (SQLException e)
  519.             {
  520.                     throw new SQLException (e.getMessage()+" column Index="+i
  521.                             +"rnSQL="+this.getCommand());
  522.             }
  523.     }
  524.     public Object getObject(String columnName) throws SQLException{
  525.             try
  526.             {
  527.                     return rs.getObject(columnName);
  528.             }
  529.             catch (SQLException e)
  530.             {
  531.                     throw new SQLException (e.getMessage()+" columnName="+columnName
  532.                             +"rnSQL="+this.getCommand());
  533.             }
  534.     }
  535.     public Object getObject(String colName, java.util.Map map) throws SQLException {
  536.             try
  537.             {
  538.                     return rs.getObject(colName,map);
  539.             }
  540.             catch (SQLException e)
  541.             {
  542.                     throw new SQLException (e.getMessage()+" columnName="+colName
  543.                             +"rnSQL="+this.getCommand());
  544.             }
  545.     }
  548.     public Ref getRef(int i) throws SQLException {
  549.             return rs.getRef(i);
  550.     }
  551.     public Ref getRef(String colName) throws SQLException {
  552.             return rs.getRef(colName);
  553.     }
  554.     public int getRow() throws SQLException {
  555.             return rs.getRow();
  556.     }
  558.     public short getShort(int columnIndex) throws SQLException {
  559.             try
  560.             {
  561.                     return rs.getShort(columnIndex);
  562.             }
  563.             catch (SQLException e)
  564.             {
  565.                     throw new SQLException (e.getMessage()+" column Index="+columnIndex
  566.                             +"rnSQL="+this.getCommand());
  567.             }
  569.     }
  570.     public short getShort(String columnName) throws SQLException {
  571.             try
  572.             {
  573.                     return rs.getShort(columnName);
  574.             }
  575.             catch (SQLException e)
  576.             {
  577.                     throw new SQLException (e.getMessage()+" columnName="+columnName
  578.                             +"rnSQL="+this.getCommand());
  579.             }
  581.     }
  582.     public Statement getStatement() throws SQLException {
  583.             return rs.getStatement();
  584.     }
  585.     public String getString(int columnIndex) throws SQLException {
  586.             try
  587.             {
  588.                     return rs.getString(columnIndex);
  589.             }
  590.             catch (SQLException e)
  591.             {
  592.                     throw new SQLException (e.getMessage()+" column Index="+columnIndex
  593.                             +"rnSQL="+this.getCommand());
  594.             }
  595.     }
  596.     public String getString(String columnName) throws SQLException{
  597.             try
  598.             {
  599.                     return rs.getString(columnName);
  600.             }
  601.             catch (SQLException e)
  602.             {
  603.                     throw new SQLException (e.toString()+" columnName="
  604.                             +columnName+"rnSQL="+this.getCommand());
  605.             }
  606.     }
  607.     public Time getTime(int columnIndex) throws SQLException {
  608.             try
  609.             {
  610.                     return rs.getTime(columnIndex);
  611.             }
  612.             catch (SQLException e)
  613.             {
  614.                     throw new SQLException (e.getMessage()+" column Index="+columnIndex
  615.                             +"rnSQL="+this.getCommand());
  616.             }
  617.     }
  618.     public Time getTime(int columnIndex, java.util.Calendar cal) throws SQLException {
  619.             try
  620.             {
  621.                     return rs.getTime(columnIndex,cal);
  622.             }
  623.             catch (SQLException e)
  624.             {
  625.                     throw new SQLException (e.getMessage()+" column Index="+columnIndex
  626.                             +"rnSQL="+this.getCommand());
  627.             }
  628.     }
  629.     public Time getTime(String columnName) throws SQLException{
  630.             try
  631.             {
  632.                     return rs.getTime(columnName);
  633.             }
  634.             catch (SQLException e)
  635.             {
  636.                     throw new SQLException (e.getMessage()+" columnName="+columnName
  637.                             +"rnSQL="+this.getCommand());
  638.             }
  639.     }
  640.     public Time getTime(String columnName, java.util.Calendar cal) throws SQLException {
  641.             try
  642.             {
  643.                     return rs.getTime(columnName,cal);
  644.             }
  645.             catch (SQLException e)
  646.             {
  647.                     throw new SQLException (e.getMessage()+" columnName="+columnName
  648.                             +"rnSQL="+this.getCommand());
  649.             }
  651.     }
  652.     public Timestamp getTimestamp(int columnIndex) throws SQLException {
  653.             try
  654.             {
  655.                     return rs.getTimestamp(columnIndex);
  656.             }
  657.             catch (SQLException e)
  658.             {
  659.                     throw new SQLException (e.getMessage()+" column Index="+columnIndex
  660.                             +"rnSQL="+this.getCommand());
  661.             }
  662.     }
  663.     public Timestamp getTimestamp(int columnIndex, java.util.Calendar cal) throws SQLException{
  664.             try
  665.             {
  667.                     return rs.getTimestamp(columnIndex,cal);
  668.             }
  669.             catch (SQLException e)
  670.             {
  671.                     throw new SQLException (e.getMessage()+" column Index="+columnIndex
  672.                             +"rnSQL="+this.getCommand());
  673.             }
  675.     }
  676.     public Timestamp getTimestamp(String columnName) throws SQLException{
  678.             try
  679.             {
  680.                     return rs.getTimestamp(columnName);
  681.             }
  682.             catch (SQLException e)
  683.             {
  684.                     throw new SQLException (e.getMessage()+" columnName="+columnName
  685.                             +"rnSQL="+this.getCommand());
  686.             }
  687.     }
  688.     public Timestamp getTimestamp(String columnName, java.util.Calendar cal) throws SQLException{
  689.             try
  690.             {
  691.                     return rs.getTimestamp(columnName,cal);
  692.             }
  693.             catch (SQLException e)
  694.             {
  695.                     throw new SQLException (e.getMessage()+" columnName="+columnName
  696.                             +"rnSQL="+this.getCommand());
  697.             }
  699.     }
  700.     public int getType() throws SQLException {
  701.             return rs.getType();
  702.     }
  703.     public java.io.InputStream getUnicodeStream(int columnIndex) throws SQLException {
  704.             throw new SQLException("Deprecated Method, Don't Call it!","user");
  705.     }
  706.     public java.io.InputStream getUnicodeStream(String columnName) throws SQLException {
  707.             throw new SQLException("Deprecated Method, Don't Call it!","user");
  708.     }
  709.     public SQLWarning getWarnings() throws SQLException {
  710.             return rs.getWarnings();
  711.     }
  712.   
  713.     public void insertRow() throws SQLException {
  714.             rs.insertRow();
  715.     }
  716.     public boolean isAfterLast() throws SQLException {
  717.             return rs.isAfterLast();
  718.     }
  719.     public boolean isBeforeFirst() throws SQLException {
  720.             return rs.isBeforeFirst();
  721.     }
  722.     public boolean isFirst() throws SQLException {
  723.             return rs.isFirst();
  724.     }
  725.     public boolean isLast() throws SQLException {
  726.             return rs.isLast();
  727.     }
  728.     public boolean last() throws SQLException {
  729.             return rs.last();
  730.     }
  731.     public void moveToCurrentRow() throws SQLException {
  732.             rs.moveToCurrentRow();
  733.     }
  734.     public void moveToInsertRow() throws SQLException {
  735.             rs.moveToInsertRow();
  736.     }
  737.     public boolean next() throws SQLException {
  738.             return rs.next();
  739.     }
  740.     public boolean previous() throws SQLException {
  741.             return rs.previous();
  742.     }
  743.     public void refreshRow() throws SQLException {
  744.             rs.refreshRow();
  745.     }
  746.     public boolean relative(int rows) throws SQLException {
  747.             return rs.relative(rows);
  748.     }
  749.     public boolean rowDeleted() throws SQLException {
  750.             return rs.rowDeleted();
  751.     }
  752.     public boolean rowInserted() throws SQLException {
  753.             return rs.rowInserted();
  754.     }
  755.     public boolean rowUpdated() throws SQLException {
  756.             return rs.rowUpdated();
  757.     }
  758.     public void setFetchDirection(int direction) throws SQLException {
  759.             rs.setFetchDirection(direction);
  760.     }
  761.     public void setFetchSize(int rows) throws SQLException {
  762.             rs.setFetchSize(rows);
  763.     }  
  764.     public void updateAsciiStream(int columnIndex, java.io.InputStream x, int length) throws SQLException {
  765.             rs.updateAsciiStream(columnIndex,x,length);
  766.     }
  767.     public void updateAsciiStream(String columnName, java.io.InputStream x, int length) throws SQLException {
  768.             rs.updateAsciiStream(columnName,x,length);
  769.     }
  770.     public void updateBigDecimal(int columnIndex, java.math.BigDecimal x) throws SQLException {
  771.             rs.updateBigDecimal(columnIndex,x);
  772.     }
  773.     public void updateBigDecimal(String columnName, java.math.BigDecimal x) throws SQLException {
  774.             rs.updateBigDecimal(columnName,x);
  775.     }
  776.     public void updateBinaryStream(int columnIndex, java.io.InputStream x, int length) throws SQLException {
  777.             rs.updateBinaryStream(columnIndex,x,length);
  778.     }
  779.     public void updateBinaryStream(String columnName, java.io.InputStream x, int length) throws SQLException {
  780.             rs.updateBinaryStream(columnName,x,length);
  781.     }
  782.     public void updateBoolean(int columnIndex, boolean x) throws SQLException {
  783.             rs.updateBoolean(columnIndex,x);
  784.     }
  785.     public void updateBoolean(String columnName, boolean x) throws SQLException {
  786.             rs.updateBoolean(columnName,x);
  787.     }
  788.     public void updateByte(int columnIndex, byte x) throws SQLException {
  789.             rs.updateByte(columnIndex,x);
  790.     }
  791.     public void updateByte(String columnName, byte x) throws SQLException {
  792.             rs.updateByte(columnName,x);
  793.     }
  794.     public void updateBytes(int columnIndex, byte[] x) throws SQLException {
  795.             rs.updateBytes(columnIndex,x);
  796.     }
  797.     public void updateBytes(String columnName, byte[] x) throws SQLException {
  798.             rs.updateBytes(columnName,x);
  799.     }
  800.     ///////////////////////////////////////////////////
  801.     public void updateArray(int columnIndex, java.sql.Array x) throws SQLException{
  802.         rs.updateArray(columnIndex, x);
  803.     }
  804.     public void updateArray(String columnName, java.sql.Array x) throws SQLException{
  805.         rs.updateArray(columnName, x);
  806.     }
  807.     public void updateBlob(int columnIndex, java.sql.Blob x) throws SQLException{
  808.         rs.updateBlob(columnIndex,x);
  809.     }
  810.     public void updateBlob(String columnIndex, java.sql.Blob x) throws SQLException{
  811.         rs.updateBlob(columnIndex,x);
  812.     } 
  813.     public void updateClob(int columnIndex, java.sql.Clob x) throws SQLException{
  814.         rs.updateClob(columnIndex, x);
  815.     }
  816.     public void updateClob(String columnIndex, java.sql.Clob x) throws SQLException{
  817.         rs.updateClob(columnIndex, x);
  818.     }    
  819.     public void updateRef(int columnIndex, java.sql.Ref x) throws SQLException{
  820.             rs.updateRef(columnIndex, x);
  821.     }
  822.     public void updateRef(String columnName, java.sql.Ref x) throws SQLException{
  823.         rs.updateRef(columnName, x);
  824.     }
  825.     /////////////////////////////////////////////////////
  826.     public void updateCharacterStream(int columnIndex, java.io.Reader x, int length) throws SQLException {
  827.             rs.updateCharacterStream(columnIndex,x,length);
  828.     }
  829.     public void updateCharacterStream(String columnName, java.io.Reader reader, int length) throws SQLException {
  830.             rs.updateCharacterStream(columnName,reader,length);
  831.     }
  832.     public void updateDate(int columnIndex, Date x) throws SQLException {
  833.             rs.updateDate(columnIndex,x);
  834.     }
  835.     public void updateDate(String columnName, Date x) throws SQLException {
  836.             rs.updateDate(columnName,x);
  837.     }
  838.     public void updateDouble(int columnIndex, double x) throws SQLException {
  839.             rs.updateDouble(columnIndex,x);
  840.     }
  841.     public void updateDouble(String columnName, double x) throws SQLException {
  842.             rs.updateDouble(columnName,x);
  843.     }
  844.     public void updateFloat(int columnIndex, float x) throws SQLException {
  845.             rs.updateFloat(columnIndex,x);
  846.     }
  847.     public void updateFloat(String columnName, float x) throws SQLException {
  848.             rs.updateFloat(columnName,x);
  849.     }
  850.     public void updateInt(int columnIndex, int x) throws SQLException {
  851.             rs.updateInt(columnIndex,x);
  852.     }
  853.     public void updateInt(String columnName, int x) throws SQLException {
  854.             rs.updateInt(columnName,x);
  855.     }
  856.     public void updateLong(int columnIndex, long x) throws SQLException {
  857.             rs.updateLong(columnIndex,x);
  858.     }
  859.     public void updateLong(String columnName, long x) throws SQLException {
  860.             rs.updateLong(columnName,x);
  861.     }
  862.     public void updateNull(int columnIndex) throws SQLException {
  863.             rs.updateNull(columnIndex);
  864.     }
  865.     public void updateNull(String columnName) throws SQLException {
  866.             rs.updateNull(columnName);
  867.     }
  868.     public void updateObject(int columnIndex, Object x) throws SQLException {
  869.             rs.updateObject(columnIndex,x);
  870.     }
  871.     public void updateObject(int columnIndex, Object x, int scale) throws SQLException {
  872.             rs.updateObject(columnIndex,x,scale);
  873.     }
  874.     public void updateObject(String columnName, Object x) throws SQLException {
  875.             rs.updateObject(columnName,x);
  876.     }
  877.     public void updateObject(String columnName, Object x, int scale) throws SQLException {
  878.             rs.updateObject(columnName,x,scale);
  879.     }
  880.     public void updateRow() throws SQLException {
  881.             rs.updateRow();
  882.     }
  883.     public void updateShort(int columnIndex, short x) throws SQLException {
  884.             rs.updateShort(columnIndex,x);
  885.     }
  886.     public void updateShort(String columnName, short x) throws SQLException {
  887.             rs.updateShort(columnName,x);
  888.     }
  889.     public void updateString(int columnIndex, String x) throws SQLException {
  890.             rs.updateString(columnIndex, x);
  891.     }
  892.     public void updateString(String columnName, String x) throws SQLException {
  893.             rs.updateString(columnName,x);
  894.     }
  895.     public void updateTime(int columnIndex, Time x) throws SQLException {
  896.             rs.updateTime(columnIndex,x);
  897.     }
  898.     public void updateTime(String columnName, Time x) throws SQLException {
  899.             rs.updateTime(columnName,x);
  900.     }
  901.     public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException {
  902.             rs.updateTimestamp(columnIndex,x);
  903.     }
  904.     public void updateTimestamp(String columnName, Timestamp x) throws SQLException {
  905.             rs.updateTimestamp(columnName,x);
  906.     }
  907.     public boolean wasNull() throws SQLException {
  908.             return rs.wasNull();
  909.     }
  910. }