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