src/jdbc/JdbcSqlResultSet.java

   1
   2 package csql.jdbc;
   3
   4 import java.math.BigDecimal;
   5 import java.net.URL;
   6
   7 import java.sql.Connection;
   8 import java.sql.Statement;
   9 import java.sql.SQLException;
  10 import java.sql.ResultSet;
  11 import java.sql.ResultSetMetaData;
  12 import java.sql.SQLWarning;
  13
  14 import java.io.InputStream;
  15 import java.io.InputStreamReader;
  16 import java.io.StringBufferInputStream;
  17
  18 import java.sql.Clob;
  19 import java.sql.Blob;
  20 import java.sql.Ref;
  21 import java.sql.Array;
  22 import java.sql.Types;
  23
  24 import java.sql.RowId;
  25 import java.sql.SQLXML;
  26 import java.io.Reader;
  27 import java.sql.NClob;
  28 import java.sql.Wrapper;
  29
  30 public class JdbcSqlResultSet extends JSqlError implements ResultSet, JSqlErrorType
  31 {
  32     public JdbcSqlStatement stmt; // This guy creates me
  33     public JdbcSqlResultSetMetaData rsmd;
  34
  35     public boolean closedFlag;
  36     long curRow;
  37     int pos=0;
  38
  39     JdbcSqlResultSet()
  40     {
  41         rsmd = new JdbcSqlResultSetMetaData();
  42         closedFlag = false;
  43         curRow = -1;
  44     }
  45     void setStmt( JdbcSqlStatement jdbcStmt )
  46     {
  47         stmt = jdbcStmt;
  48         rsmd.setStmt( jdbcStmt );
  49         closedFlag = false;
  50         curRow = -1;
  51     }
  52     protected void finalize ()
  53     {
  54         try
  55         {
  56             if(!closedFlag) close();
  57         }
  58         catch(SQLException e)
  59         {
  60             System.out.println(e);
  61         }
  62     }
  63
  64     // API's
  65     public void close() throws SQLException
  66     {
  67         if( closedFlag ) return;
  68
  69         closedFlag = true;
  70         curRow = -1;
  71         //rsmd.close(); //commented by praba
  72         //after close the app can reexecute.
  73         if (stmt != null) stmt.closeScan();
  74         return;
  75     }
  76
  77     // Move to next tuple
  78     public boolean next () throws SQLException
  79     {
  80         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
  81
  82         if( 0 == stmt.jniStmt.next() )
  83         {
  84             curRow = -2;
  85             return( false );
  86         }
  87         curRow += 1;
  88
  89         return( true );
  90     }
  91     public ResultSetMetaData getMetaData () throws SQLException
  92     {
  93         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
  94         return( rsmd );
  95     }
  96     public SQLWarning getWarnings() throws SQLException
  97     {
  98         return( null );
  99     }
 100     public void clearWarnings() throws SQLException
 101     {
 102         return;
 103     }
 104     public int findColumn (String colName) throws SQLException
 105     {
 106         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 107
 108         int colnum = stmt.jniStmt.findColumn( colName );
 109         return( colnum );
 110     }
 111     public int getType() throws SQLException
 112     {
 113         return( ResultSet.TYPE_FORWARD_ONLY );
 114     }
 115     public int getConcurrency() throws SQLException
 116     {
 117         return( ResultSet.CONCUR_READ_ONLY );
 118     }
 119     public Statement getStatement() throws SQLException
 120     {
 121         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 122         return( stmt );
 123     }
 124     public boolean isFirst() throws SQLException
 125     {
 126         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 127
 128         if( curRow == 0 )
 129             return( true );
 130
 131         return( false );
 132     }
 133     public boolean isBeforeFirst() throws SQLException
 134     {
 135         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 136
 137         if( curRow == -1 )
 138             return( true );
 139
 140         return( false );
 141     }
 142     public boolean isAfterLast() throws SQLException
 143     {
 144         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 145
 146         if( curRow == -2 )
 147             return( true );
 148
 149         return( false );
 150     }
 151
 152     // Provide data to application
 153     // SHORT
 154     public short getShort (int colNum ) throws SQLException
 155     {
 156         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 157
 158         short out = stmt.jniStmt.getShort( colNum - 1 );
 159         if( false ) throw new SQLException();
 160         pos = colNum;
 161         return out;
 162     }
 163     public short getShort (String colName ) throws SQLException
 164     {
 165         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 166         return( getShort( findColumn( colName ) ) );
 167     }
 168
 169     // INTEGER
 170     public int getInt (int colNum ) throws SQLException
 171     {
 172         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 173
 174         int out = stmt.jniStmt.getInt( colNum - 1 );
 175         if( false ) throw new SQLException();
 176         pos = colNum;
 177         return out;
 178     }
 179     public int getInt (String colName) throws SQLException
 180     {
 181         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 182         return( getInt( findColumn( colName ) ) );
 183     }
 184
 185     // LONG
 186     public long getLong (int colNum) throws SQLException
 187     {
 188         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 189
 190         long out = stmt.jniStmt.getLong( colNum-1 );
 191         if( false ) throw new SQLException();
 192         pos = colNum;
 193         return out;
 194     }
 195     public long getLong (String colName) throws SQLException
 196     {
 197         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 198         return( getLong( findColumn( colName ) ) );
 199     }
 200
 201     // BYTE
 202     public byte getByte (int colNum) throws SQLException
 203     {
 204         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 205
 206         byte out = stmt.jniStmt.getByte( colNum-1 );
 207         if( false ) throw new SQLException();
 208         pos = colNum;
 209         return out;
 210     }
 211     public byte getByte (String colName) throws SQLException
 212     {
 213         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 214         return( getByte( findColumn( colName ) ) );
 215     }
 216
 217     // FLOAT
 218     public float getFloat (int colNum) throws SQLException
 219     {
 220         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 221
 222         float out = stmt.jniStmt.getFloat( colNum-1 );
 223         if( false ) throw new SQLException();
 224         pos = colNum;
 225         return out;
 226     }
 227     public float getFloat (String colName) throws SQLException
 228     {
 229         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 230         return( getFloat( findColumn( colName ) ) );
 231     }
 232
 233     // DOUBLE
 234     public double getDouble (int colNum) throws SQLException
 235     {
 236         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 237
 238         double out = stmt.jniStmt.getDouble( colNum-1 );
 239         if( false ) throw new SQLException();
 240         pos = colNum;
 241         return out;
 242     }
 243     public double getDouble (String colName) throws SQLException
 244     {
 245         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 246         return( getDouble( findColumn( colName ) ) );
 247     }
 248
 249     // DECIMAL
 250     public BigDecimal getBigDecimal( int colNum )
 251        throws SQLException
 252     {
 253         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 254
 255         throw getException( CSQL_NOT_SUPPORTED );
 256
 257         // TODO
 258         // BigDecimal out = new BigDecimal( stmt.jniStmt.getBigDecimal( colNum-1 ) );
 259         //return out;
 260     }
 261     public BigDecimal getBigDecimal(String colName)
 262        throws SQLException
 263     {
 264         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 265         return( getBigDecimal( findColumn( colName ) ) );
 266     }
 267     public BigDecimal getBigDecimal (int colNum, int scale)
 268         throws SQLException
 269     {
 270         return( getBigDecimal( colNum ) );
 271     }
 272     public BigDecimal getBigDecimal (String colName, int scale)
 273         throws SQLException
 274     {
 275         return( getBigDecimal( colName ) );
 276     }
 277
 278     // STRING/VARSTRING
 279     public String getString(int colNum) throws SQLException
 280     {
 281         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 282
 283         // Get value
 284         String out = stmt.jniStmt.getString( colNum-1 );
 285         pos = colNum;
 286         return out;
 287     }
 288     public String getString (String colName) throws SQLException
 289     {
 290         return( getString( findColumn( colName ) ) );
 291     }
 292     public InputStream getAsciiStream(int colNum) throws SQLException
 293     {
 294         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 295
 296         String out = stmt.jniStmt.getString( colNum-1 );
 297         pos = colNum;
 298         return( new StringBufferInputStream( out ) );
 299     }
 300     public java.io.InputStream getAsciiStream (String colName) throws SQLException
 301     {
 302         return( getAsciiStream( findColumn( colName ) ) );
 303     }
 304     public java.io.Reader getCharacterStream(int colNum)
 305        throws SQLException
 306     {
 307         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 308
 309         InputStream iS = getAsciiStream( colNum );
 310         if( iS == null )
 311             return( null );
 312         pos = colNum;
 313         return( new InputStreamReader( iS ) );
 314     }
 315     public java.io.Reader getCharacterStream(String colName)
 316        throws SQLException
 317     {
 318         return( getCharacterStream( findColumn( colName ) ) );
 319     }
 320
 321     // BOOLEAN
 322     public boolean getBoolean (int colNum) throws SQLException
 323     {
 324         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 325
 326         boolean out = stmt.jniStmt.getBoolean( colNum-1 );
 327         pos = colNum;
 328         return out;
 329     }
 330     public boolean getBoolean (String colName) throws SQLException
 331     {
 332         return( getBoolean( findColumn( colName ) ) );
 333     }
 334
 335     // BINARY/VARBINARY
 336         public byte [] getBytes(int colNum) throws SQLException
 337     {
 338         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 339
 340         throw getException( CSQL_NOT_SUPPORTED );
 341         //byte[] out = stmt.jniStmt.getBytes( colNum-1 );
 342         //return out;
 343     }
 344     public byte[] getBytes (String colName) throws SQLException
 345     {
 346         return( getBytes( findColumn( colName ) ) );
 347     }
 348
 349     // DATE
 350     public java.sql.Date getDate (int colNum) throws SQLException
 351     {
 352         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 353
 354         java.sql.Date out = stmt.jniStmt.getDate( colNum-1 );
 355         pos = colNum;
 356         return out;
 357     }
 358     public java.sql.Date getDate(int colNum, java.util.Calendar cal)
 359        throws SQLException
 360     {
 361         return( getDate( colNum ) );
 362     }
 363     public java.sql.Date getDate (String colNum) throws SQLException
 364     {
 365         return( getDate( findColumn( colNum ) ) );
 366     }
 367     public java.sql.Date getDate(String colName, java.util.Calendar cal)
 368        throws SQLException
 369     {
 370         return( getDate( colName ) );
 371     }
 372
 373     // TIME
 374     public java.sql.Time getTime (int colNum) throws SQLException
 375     {
 376         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 377
 378         // Get value
 379         java.sql.Time out = stmt.jniStmt.getTime( colNum-1 );
 380         pos = colNum;
 381         return out;
 382     }
 383     public java.sql.Time getTime(int colNum, java.util.Calendar cal)
 384        throws SQLException
 385     {
 386         return( getTime( colNum ) );
 387     }
 388     public java.sql.Time getTime (String colName) throws SQLException
 389     {
 390         return( getTime( findColumn( colName ) ) );
 391     }
 392     public java.sql.Time getTime(String colName, java.util.Calendar cal)
 393        throws SQLException
 394     {
 395         return( getTime( colName ) );
 396     }
 397
 398     // TIMESTAMP
 399     public java.sql.Timestamp getTimestamp (int colNum)
 400         throws SQLException
 401     {
 402         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 403
 404         java.sql.Timestamp out = stmt.jniStmt.getTimestamp( colNum-1 );
 405         pos = colNum;
 406         return out;
 407     }
 408     public java.sql.Timestamp getTimestamp(int colNum,
 409        java.util.Calendar cal) throws SQLException
 410     {
 411         return( getTimestamp( colNum ) );
 412     }
 413     public java.sql.Timestamp getTimestamp (String colName)
 414         throws SQLException
 415     {
 416         return( getTimestamp( findColumn( colName ) ) );
 417     }
 418     public java.sql.Timestamp getTimestamp(String colName,
 419        java.util.Calendar cal) throws SQLException
 420     {
 421         return( getTimestamp( colName ) );
 422     }
 423
 424     public Object getObject(int colNum) throws SQLException
 425     {
 426         Object obj = new String("no obj");
 427
 428         if( closedFlag || curRow < 0 ) throw getException( CSQL_INVALID_STATE );
 429
 430         switch ( rsmd.getColumnType( colNum ) )
 431         {
 432             case Types.DOUBLE:
 433                 obj = new Double( getDouble( colNum ) ); break;
 434             case Types.FLOAT:
 435                 obj = new Float( getFloat( colNum ) ); break;
 436             case Types.DECIMAL:
 437             case Types.NUMERIC:
 438                 obj = getBigDecimal( colNum ); break;
 439
 440             case Types.BIGINT:
 441                 obj = new Long( getLong( colNum ) ); break;
 442             case Types.INTEGER:
 443                 obj = new Integer( getInt( colNum ) ); break;
 444             case Types.SMALLINT:
 445                 obj = new Short( getShort( colNum ) ); break;
 446             case Types.TINYINT:
 447                 obj = new Byte( getByte( colNum ) ); break;
 448             case Types.BIT:
 449                 obj = new Boolean( getBoolean( colNum ) ); break;
 450
 451             case Types.DATE:
 452                 obj = getDate( colNum ); break;
 453             case Types.TIME:
 454                 obj = getTime( colNum ); break;
 455             case Types.TIMESTAMP:
 456                 obj = getTimestamp( colNum ); break;
 457
 458             case Types.CHAR:
 459                 obj = getString( colNum ); break;
 460             case Types.VARCHAR:
 461                 obj = getString( colNum ); break;
 462             case Types.BINARY:
 463             case Types.VARBINARY:
 464                 obj = getBytes( colNum ); break;
 465
 466             default: throw getException( CSQL_INVALID_DATATYPE );
 467         }
 468         // Return null if value read is null //TODO
 469         //if( wasNull() )
 470         //    return( null );
 471         pos = colNum;
 472         return( obj );
 473     }
 474     public Object getObject (String colName) throws SQLException
 475     {
 476         return( getObject( findColumn( colName ) ) );
 477     }
 478     public Object getObject(int i, java.util.Map map) throws SQLException
 479     {
 480         return( getObject( i ) );
 481     }
 482     public Object getObject(String colName, java.util.Map map)
 483         throws SQLException
 484     {
 485         return( getObject( colName ) );
 486     }
 487
 488     public int getRow() throws SQLException
 489     {
 490         if( curRow < 0 )
 491             return( 0 );
 492
 493         return( (int) curRow + 1 );
 494     }
 495
 496     // UN-SUPPORTED API's
 497     public boolean wasNull () throws SQLException // TODO
 498     {
 499         if( closedFlag ) throw getException( CSQL_INVALID_STATE );
 500         //throw getException( CSQL_NOT_SUPPORTED );
 501         return( stmt.jniStmt.isNull(pos) );
 502     }
 503     public String getCursorName () throws SQLException
 504     {
 505         throw getException( CSQL_NOT_SUPPORTED );
 506     }
 507     public boolean absolute( int row ) throws SQLException
 508     {
 509         throw getException( CSQL_NOT_SUPPORTED );
 510     }
 511     public void beforeFirst() throws SQLException
 512     {
 513         throw getException( CSQL_NOT_SUPPORTED );
 514     }
 515     public void afterLast() throws SQLException
 516     {
 517         throw getException( CSQL_NOT_SUPPORTED );
 518     }
 519     public boolean first() throws SQLException
 520     {
 521         throw getException( CSQL_NOT_SUPPORTED );
 522     }
 523     public boolean last() throws SQLException
 524     {
 525         throw getException( CSQL_NOT_SUPPORTED );
 526     }
 527     public boolean relative( int rows ) throws SQLException
 528     {
 529         throw getException( CSQL_NOT_SUPPORTED );
 530     }
 531     public boolean previous() throws SQLException
 532     {
 533         throw getException( CSQL_NOT_SUPPORTED );
 534     }
 535     public void setFetchDirection(int direction) throws SQLException
 536     {
 537         throw getException( CSQL_NOT_SUPPORTED );
 538     }
 539     public int getFetchDirection() throws SQLException
 540     {
 541         throw getException( CSQL_NOT_SUPPORTED );
 542     }
 543     public void setFetchSize(int rows) throws SQLException
 544     {
 545         throw getException( CSQL_NOT_SUPPORTED );
 546     }
 547     public int getFetchSize() throws SQLException
 548     {
 549         throw getException( CSQL_NOT_SUPPORTED );
 550     }
 551         public InputStream getUnicodeStream(int colNum) throws SQLException
 552     {
 553         throw getException( CSQL_NOT_SUPPORTED );
 554     }
 555         public InputStream getBinaryStream(int colNum) throws SQLException
 556     {
 557         throw getException( CSQL_NOT_SUPPORTED );
 558     }
 559     public java.io.InputStream getUnicodeStream (String colName) throws SQLException
 560     {
 561         throw getException( CSQL_NOT_SUPPORTED );
 562     }
 563     public java.io.InputStream getBinaryStream (String colName) throws SQLException
 564     {
 565         throw getException( CSQL_NOT_SUPPORTED );
 566     }
 567     public void setMaxRows(int maxRows) throws SQLException
 568     {
 569         throw getException( CSQL_NOT_SUPPORTED );
 570     }
 571     public void setMaxFieldSize(int maxFieldSize) throws SQLException
 572     {
 573         throw getException( CSQL_NOT_SUPPORTED );
 574     }
 575     public boolean rowUpdated() throws SQLException
 576     {
 577         throw getException( CSQL_NOT_SUPPORTED );
 578     }
 579     public boolean rowInserted() throws SQLException
 580     {
 581         throw getException( CSQL_NOT_SUPPORTED );
 582     }
 583     public boolean rowDeleted() throws SQLException
 584     {
 585         throw getException( CSQL_NOT_SUPPORTED );
 586     }
 587     public void updateNull(int colNum) throws SQLException
 588     {
 589         throw getException( CSQL_NOT_SUPPORTED );
 590     }
 591     public void updateBoolean(int colNum, boolean x) throws SQLException
 592     {
 593         throw getException( CSQL_NOT_SUPPORTED );
 594     }
 595     public void updateByte(int colNum, byte x) throws SQLException
 596     {
 597         throw getException( CSQL_NOT_SUPPORTED );
 598     }
 599     public void updateShort(int colNum, short x) throws SQLException
 600     {
 601         throw getException( CSQL_NOT_SUPPORTED );
 602     }
 603     public void updateInt(int colNum, int x) throws SQLException
 604     {
 605         throw getException( CSQL_NOT_SUPPORTED );
 606     }
 607     public void updateLong(int colNum, long x) throws SQLException
 608     {
 609         throw getException( CSQL_NOT_SUPPORTED );
 610     }
 611     public void updateFloat(int colNum, float x) throws SQLException
 612     {
 613         throw getException( CSQL_NOT_SUPPORTED );
 614     }
 615     public void updateDouble(int colNum, double x) throws SQLException
 616     {
 617         throw getException( CSQL_NOT_SUPPORTED );
 618     }
 619     public void updateBigDecimal(int colNum, BigDecimal x) throws SQLException
 620     {
 621         throw getException( CSQL_NOT_SUPPORTED );
 622     }
 623     public void updateString(int colNum, String x) throws SQLException
 624     {
 625         throw getException( CSQL_NOT_SUPPORTED );
 626     }
 627     public void updateBytes(int colNum, byte x[]) throws SQLException
 628     {
 629         throw getException( CSQL_NOT_SUPPORTED );
 630     }
 631     public void updateDate(int colNum, java.sql.Date x) throws SQLException
 632     {
 633         throw getException( CSQL_NOT_SUPPORTED );
 634     }
 635     public void updateTime(int colNum, java.sql.Time x) throws SQLException
 636     {
 637         throw getException( CSQL_NOT_SUPPORTED );
 638     }
 639     public void updateTimestamp(int colNum, java.sql.Timestamp x)
 640        throws SQLException
 641     {
 642         throw getException( CSQL_NOT_SUPPORTED );
 643     }
 644     public void updateAsciiStream(int colNum,
 645        java.io.InputStream x, int length) throws SQLException
 646     {
 647         throw getException( CSQL_NOT_SUPPORTED );
 648     }
 649     public void updateBinaryStream(int colNum,
 650        java.io.InputStream x, int length) throws SQLException
 651     {
 652         throw getException( CSQL_NOT_SUPPORTED );
 653     }
 654     public void updateCharacterStream(int colNum,
 655        java.io.Reader x, int length) throws SQLException
 656     {
 657         throw getException( CSQL_NOT_SUPPORTED );
 658     }
 659     public void updateNull(String colName) throws SQLException
 660     {
 661         throw getException( CSQL_NOT_SUPPORTED );
 662     }
 663     public void updateBoolean(String colName, boolean x) throws SQLException
 664     {
 665         throw getException( CSQL_NOT_SUPPORTED );
 666     }
 667     public void updateByte(String colName, byte x) throws SQLException
 668     {
 669         throw getException( CSQL_NOT_SUPPORTED );
 670     }
 671     public void updateShort(String colName, short x) throws SQLException
 672     {
 673         throw getException( CSQL_NOT_SUPPORTED );
 674     }
 675     public void updateInt(String colName, int x) throws SQLException
 676     {
 677         throw getException( CSQL_NOT_SUPPORTED );
 678     }
 679     public void updateLong(String colName, long x) throws SQLException
 680     {
 681         throw getException( CSQL_NOT_SUPPORTED );
 682     }
 683     public void updateFloat(String colName, float x) throws SQLException
 684     {
 685         throw getException( CSQL_NOT_SUPPORTED );
 686     }
 687     public void updateDouble(String colName, double x) throws SQLException
 688     {
 689         throw getException( CSQL_NOT_SUPPORTED );
 690     }
 691     public void updateBigDecimal(String colName, BigDecimal x)
 692         throws SQLException
 693     {
 694         throw getException( CSQL_NOT_SUPPORTED );
 695     }
 696     public void updateString(String colName, String x) throws SQLException
 697     {
 698         throw getException( CSQL_NOT_SUPPORTED );
 699     }
 700     public void updateBytes(String colName, byte x[]) throws SQLException
 701     {
 702         throw getException( CSQL_NOT_SUPPORTED );
 703     }
 704     public void updateDate(String colName, java.sql.Date x) throws SQLException
 705     {
 706         throw getException( CSQL_NOT_SUPPORTED );
 707     }
 708     public void updateTime(String colName, java.sql.Time x) throws SQLException
 709     {
 710         throw getException( CSQL_NOT_SUPPORTED );
 711     }
 712     public void updateTimestamp(String colName, java.sql.Timestamp x)
 713       throws SQLException
 714     {
 715         throw getException( CSQL_NOT_SUPPORTED );
 716     }
 717     public void updateAsciiStream(String colName,
 718       java.io.InputStream x, int length) throws SQLException
 719     {
 720         throw getException( CSQL_NOT_SUPPORTED );
 721     }
 722     public void updateBinaryStream(String colName,
 723       java.io.InputStream x, int length) throws SQLException
 724     {
 725         throw getException( CSQL_NOT_SUPPORTED );
 726     }
 727     public void updateCharacterStream(String colName,
 728       java.io.Reader reader, int length) throws SQLException
 729     {
 730         throw getException( CSQL_NOT_SUPPORTED );
 731     }
 732     public void updateObject(int colNum, Object x, int scale)
 733       throws SQLException
 734     {
 735         throw getException( CSQL_NOT_SUPPORTED );
 736     }
 737     public void updateObject(int colNum, Object x) throws SQLException
 738     {
 739         throw getException( CSQL_NOT_SUPPORTED );
 740     }
 741     public void insertRow() throws SQLException
 742     {
 743         throw getException( CSQL_NOT_SUPPORTED );
 744     }
 745     public void updateRow() throws SQLException
 746     {
 747         throw getException( CSQL_NOT_SUPPORTED );
 748     }
 749     public void deleteRow() throws SQLException
 750     {
 751         throw getException( CSQL_NOT_SUPPORTED );
 752     }
 753     public void refreshRow() throws SQLException
 754     {
 755         throw getException( CSQL_NOT_SUPPORTED );
 756     }
 757     public void cancelRowUpdates() throws SQLException
 758     {
 759         throw getException( CSQL_NOT_SUPPORTED );
 760     }
 761     public void moveToInsertRow() throws SQLException
 762     {
 763         throw getException( CSQL_NOT_SUPPORTED );
 764     }
 765     public void moveToCurrentRow() throws SQLException
 766     {
 767         throw getException( CSQL_NOT_SUPPORTED );
 768     }
 769     public Ref getRef(int i) throws SQLException
 770     {
 771         throw getException( CSQL_NOT_SUPPORTED );
 772     }
 773     public Blob getBlob(int i) throws SQLException
 774     {
 775         throw getException( CSQL_NOT_SUPPORTED );
 776     }
 777     public Clob getClob(int i) throws SQLException
 778     {
 779         throw getException( CSQL_NOT_SUPPORTED );
 780     }
 781     public Array getArray(int i) throws SQLException
 782     {
 783         throw getException( CSQL_NOT_SUPPORTED );
 784     }
 785     public Ref getRef(String colName) throws SQLException
 786     {
 787         throw getException( CSQL_NOT_SUPPORTED );
 788     }
 789     public Blob getBlob(String colName) throws SQLException
 790     {
 791         throw getException( CSQL_NOT_SUPPORTED );
 792     }
 793     public Clob getClob(String colName) throws SQLException
 794     {
 795         throw getException( CSQL_NOT_SUPPORTED );
 796     }
 797     public Array getArray(String colName) throws SQLException
 798     {
 799         throw getException( CSQL_NOT_SUPPORTED );
 800     }
 801     public    boolean isLast() throws SQLException
 802     {
 803         throw getException( CSQL_NOT_SUPPORTED );
 804     }
 805     public void updateObject(String colName, Object x) throws SQLException
 806     {
 807         throw getException( CSQL_NOT_SUPPORTED );
 808     }
 809     public    void updateObject(String colName, Object x, int scale)
 810                                                     throws SQLException
 811     {
 812         throw getException( CSQL_NOT_SUPPORTED );
 813     }
 814     public URL getURL(int colNum)
 815                         throws SQLException
 816     {
 817         throw getException( CSQL_NOT_SUPPORTED );
 818     }
 819     public URL getURL(String colName)
 820                         throws SQLException
 821     {
 822         throw getException( CSQL_NOT_SUPPORTED );
 823     }
 824     public void updateRef(int colNum, Ref x)
 825                         throws SQLException
 826     {
 827         throw getException( CSQL_NOT_SUPPORTED );
 828     }
 829     public void updateRef(String colName, Ref x)
 830                         throws SQLException
 831     {
 832         throw getException( CSQL_NOT_SUPPORTED );
 833     }
 834     public void updateBlob(int colNum, Blob x)
 835                          throws SQLException
 836     {
 837         throw getException( CSQL_NOT_SUPPORTED );
 838     }
 839     public void updateBlob(String colName, Blob x)
 840                          throws SQLException
 841     {
 842         throw getException( CSQL_NOT_SUPPORTED );
 843     }
 844     public void updateClob(int colNum, Clob x)
 845                          throws SQLException
 846     {
 847         throw getException( CSQL_NOT_SUPPORTED );
 848     }
 849     public void updateClob(String colName, Clob x)
 850                          throws SQLException
 851     {
 852         throw getException( CSQL_NOT_SUPPORTED );
 853     }
 854     public void updateArray(int colNum, Array x)
 855                           throws SQLException
 856     {
 857         throw getException( CSQL_NOT_SUPPORTED );
 858     }
 859     public void updateArray(String colName, Array x)
 860                           throws SQLException
 861     {
 862         throw getException( CSQL_NOT_SUPPORTED );
 863     }
 864     //java 1.6 methods
 865     public void updateRowId(int colIndex, RowId x)
 866                                              throws SQLException
 867     {
 868         throw getException( CSQL_NOT_SUPPORTED );
 869     }
 870     public void updateRowId(String colLabel, RowId x)
 871                                              throws SQLException
 872     {
 873         throw getException( CSQL_NOT_SUPPORTED );
 874     }
 875     public void updateSQLXML(int colIndex, SQLXML x)
 876                                              throws SQLException
 877     {
 878         throw getException( CSQL_NOT_SUPPORTED );
 879     }
 880     public void updateSQLXML(String colLabel, SQLXML x)
 881                                              throws SQLException
 882     {
 883         throw getException( CSQL_NOT_SUPPORTED );
 884     }
 885     public void updateNClob(int colIndex, NClob x)
 886                                              throws SQLException
 887     {
 888         throw getException( CSQL_NOT_SUPPORTED );
 889     }
 890     public void updateNClob(int colIndex, Reader x)
 891                                              throws SQLException
 892     {
 893         throw getException( CSQL_NOT_SUPPORTED );
 894     }
 895     public void updateNClob(int colIndex, Reader x, long length)
 896                                              throws SQLException
 897     {
 898         throw getException( CSQL_NOT_SUPPORTED );
 899     }
 900     public void updateNClob(String colIndex, NClob x)
 901                                              throws SQLException
 902     {
 903         throw getException( CSQL_NOT_SUPPORTED );
 904     }
 905     public void updateNClob(String colIndex, Reader x)
 906                                              throws SQLException
 907     {
 908         throw getException( CSQL_NOT_SUPPORTED );
 909     }
 910     public void updateNClob(String colIndex, Reader x, long length)
 911                                              throws SQLException
 912     {
 913         throw getException( CSQL_NOT_SUPPORTED );
 914     }
 915     public void updateNString(int colIndex, String x)
 916                                              throws SQLException
 917     {
 918         throw getException( CSQL_NOT_SUPPORTED );
 919     }
 920     public void updateNString(String colIndex, String x)
 921                                              throws SQLException
 922     {
 923         throw getException( CSQL_NOT_SUPPORTED );
 924     }
 925     public void updateNCharacterStream(int colIndex, Reader x)
 926                                              throws SQLException
 927     {
 928         throw getException( CSQL_NOT_SUPPORTED );
 929     }
 930     public void updateNCharacterStream(int colIndex, Reader x, long length)
 931                                              throws SQLException
 932     {
 933         throw getException( CSQL_NOT_SUPPORTED );
 934     }
 935     public void updateNCharacterStream(String colIndex, Reader x)
 936                                              throws SQLException
 937     {
 938         throw getException( CSQL_NOT_SUPPORTED );
 939     }
 940     public void updateNCharacterStream(String colIndex, Reader x, long length)
 941                                              throws SQLException
 942     {
 943         throw getException( CSQL_NOT_SUPPORTED );
 944     }
 945     public void updateCharacterStream(int colIndex, Reader x)
 946                                              throws SQLException
 947     {
 948         throw getException( CSQL_NOT_SUPPORTED );
 949     }
 950     public void updateCharacterStream(String colIndex, Reader x)
 951                                              throws SQLException
 952     {
 953         throw getException( CSQL_NOT_SUPPORTED );
 954     }
 955     public void updateCharacterStream(int colIndex, Reader x, long length)
 956                                              throws SQLException
 957     {
 958         throw getException( CSQL_NOT_SUPPORTED );
 959     }
 960     public void updateCharacterStream(String colIndex, Reader x, long length)
 961                                              throws SQLException
 962     {
 963         throw getException( CSQL_NOT_SUPPORTED );
 964     }
 965     public void updateBinaryStream(int colIndex, InputStream x)
 966                                              throws SQLException
 967     {
 968         throw getException( CSQL_NOT_SUPPORTED );
 969     }
 970     public void updateBinaryStream(String colIndex, InputStream x)
 971                                              throws SQLException
 972     {
 973         throw getException( CSQL_NOT_SUPPORTED );
 974     }
 975     public void updateBinaryStream(int colIndex, InputStream x, long length)
 976                                              throws SQLException
 977     {
 978         throw getException( CSQL_NOT_SUPPORTED );
 979     }
 980     public void updateBinaryStream(String colIndex, InputStream x, long length)
 981                                              throws SQLException
 982     {
 983         throw getException( CSQL_NOT_SUPPORTED );
 984     }
 985     public void updateAsciiStream(int colIndex, InputStream x)
 986                                              throws SQLException
 987     {
 988         throw getException( CSQL_NOT_SUPPORTED );
 989     }
 990     public void updateAsciiStream(String colIndex, InputStream x)
 991                                              throws SQLException
 992     {
 993         throw getException( CSQL_NOT_SUPPORTED );
 994     }
 995     public void updateAsciiStream(int colIndex, InputStream x, long length)
 996                                              throws SQLException
 997     {
 998         throw getException( CSQL_NOT_SUPPORTED );
 999     }
1000     public void updateAsciiStream(String colIndex, InputStream x, long length)
1001                                              throws SQLException
1002     {
1003         throw getException( CSQL_NOT_SUPPORTED );
1004     }
1005     public void updateClob(int colNum, Reader x) throws SQLException
1006     {
1007         throw getException( CSQL_NOT_SUPPORTED );
1008     }
1009     public void updateClob(String colNum, Reader x) throws SQLException
1010     {
1011         throw getException( CSQL_NOT_SUPPORTED );
1012     }
1013     public void updateClob(int colNum, Reader x, long length)
1014                                                   throws SQLException
1015     {
1016         throw getException( CSQL_NOT_SUPPORTED );
1017     }
1018     public void updateClob(String colNum, Reader x, long length)
1019                                                   throws SQLException
1020     {
1021         throw getException( CSQL_NOT_SUPPORTED );
1022     }
1023     public void updateBlob(int colNum, InputStream x) throws SQLException
1024     {
1025         throw getException( CSQL_NOT_SUPPORTED );
1026     }
1027     public void updateBlob(String colNum, InputStream x) throws SQLException
1028     {
1029         throw getException( CSQL_NOT_SUPPORTED );
1030     }
1031     public void updateBlob(int colNum, InputStream x, long length)
1032                                                     throws SQLException
1033     {
1034         throw getException( CSQL_NOT_SUPPORTED );
1035     }
1036     public void updateBlob(String colNum, InputStream x, long length)
1037                                                      throws SQLException
1038     {
1039         throw getException( CSQL_NOT_SUPPORTED );
1040     }
1041     public Reader getNCharacterStream(int colIndex) throws SQLException
1042     {
1043         throw getException( CSQL_NOT_SUPPORTED );
1044     }
1045     public Reader getNCharacterStream(String colLabel) throws SQLException
1046     {
1047         throw getException( CSQL_NOT_SUPPORTED );
1048     }
1049     public NClob getNClob(int colIndex) throws SQLException
1050     {
1051         throw getException( CSQL_NOT_SUPPORTED );
1052     }
1053     public NClob getNClob(String colLabel) throws SQLException
1054     {
1055         throw getException( CSQL_NOT_SUPPORTED );
1056     }
1057     public String getNString(int colIndex) throws SQLException
1058     {
1059         throw getException( CSQL_NOT_SUPPORTED );
1060     }
1061     public String getNString(String colLabel) throws SQLException
1062     {
1063         throw getException( CSQL_NOT_SUPPORTED );
1064     }
1065     public SQLXML getSQLXML(int colIndex) throws SQLException
1066     {
1067         throw getException(CSQL_NOT_SUPPORTED);
1068     }
1069     public SQLXML getSQLXML(String colLabel) throws SQLException
1070     {
1071         throw getException(CSQL_NOT_SUPPORTED);
1072     }
1073     public boolean isClosed()
1074     {
1075         return closedFlag;
1076     }
1077     public int getHoldability() throws SQLException
1078     {
1079         throw getException(CSQL_NOT_SUPPORTED);
1080     }
1081     public RowId getRowId(int val) throws SQLException
1082     {
1083         throw getException(CSQL_NOT_SUPPORTED);
1084     }
1085     public RowId getRowId(String val) throws SQLException
1086     {
1087         throw getException(CSQL_NOT_SUPPORTED);
1088     }
1089     public boolean isWrapperFor(Class ifact) throws SQLException
1090     {
1091         throw getException(CSQL_NOT_SUPPORTED);
1092     }
1093     public Class unwrap(Class iface) throws SQLException
1094     {
1095         throw getException(CSQL_NOT_SUPPORTED);
1096     }
1097 }